#include "winsock2.h"
#include "windef.h"
#include "winbase.h"
+#include "ws2tcpip.h"
#include "iphlpapi.h"
#include "iprtrmib.h"
+#include "netioapi.h"
#include "wine/test.h"
#include <stdio.h>
#include <stdlib.h>
+#define ICMP_MINLEN 8 /* copied from dlls/iphlpapi/ip_icmp.h file */
+
#undef htonl
#undef htons
#undef ntohl
static HMODULE hLibrary = NULL;
-typedef DWORD (WINAPI *GetNumberOfInterfacesFunc)(PDWORD);
-typedef DWORD (WINAPI *GetIpAddrTableFunc)(PMIB_IPADDRTABLE,PULONG,BOOL);
-typedef DWORD (WINAPI *GetIfEntryFunc)(PMIB_IFROW);
-typedef DWORD (WINAPI *GetFriendlyIfIndexFunc)(DWORD);
-typedef DWORD (WINAPI *GetIfTableFunc)(PMIB_IFTABLE,PULONG,BOOL);
-typedef DWORD (WINAPI *GetIpForwardTableFunc)(PMIB_IPFORWARDTABLE,PULONG,BOOL);
-typedef DWORD (WINAPI *GetIpNetTableFunc)(PMIB_IPNETTABLE,PULONG,BOOL);
-typedef DWORD (WINAPI *GetInterfaceInfoFunc)(PIP_INTERFACE_INFO,PULONG);
-typedef DWORD (WINAPI *GetAdaptersInfoFunc)(PIP_ADAPTER_INFO,PULONG);
-typedef DWORD (WINAPI *GetNetworkParamsFunc)(PFIXED_INFO,PULONG);
-typedef DWORD (WINAPI *GetIcmpStatisticsFunc)(PMIB_ICMP);
-typedef DWORD (WINAPI *GetIpStatisticsFunc)(PMIB_IPSTATS);
-typedef DWORD (WINAPI *GetTcpStatisticsFunc)(PMIB_TCPSTATS);
-typedef DWORD (WINAPI *GetUdpStatisticsFunc)(PMIB_UDPSTATS);
-typedef DWORD (WINAPI *GetTcpTableFunc)(PMIB_TCPTABLE,PDWORD,BOOL);
-typedef DWORD (WINAPI *GetUdpTableFunc)(PMIB_UDPTABLE,PDWORD,BOOL);
-typedef DWORD (WINAPI *GetPerAdapterInfoFunc)(ULONG,PIP_PER_ADAPTER_INFO,PULONG);
-typedef DWORD (WINAPI *GetAdaptersAddressesFunc)(ULONG,ULONG,PVOID,PIP_ADAPTER_ADDRESSES,PULONG);
-typedef DWORD (WINAPI *NotifyAddrChangeFunc)(PHANDLE,LPOVERLAPPED);
-typedef BOOL (WINAPI *CancelIPChangeNotifyFunc)(LPOVERLAPPED);
-
-static GetNumberOfInterfacesFunc gGetNumberOfInterfaces = NULL;
-static GetIpAddrTableFunc gGetIpAddrTable = NULL;
-static GetIfEntryFunc gGetIfEntry = NULL;
-static GetFriendlyIfIndexFunc gGetFriendlyIfIndex = NULL;
-static GetIfTableFunc gGetIfTable = NULL;
-static GetIpForwardTableFunc gGetIpForwardTable = NULL;
-static GetIpNetTableFunc gGetIpNetTable = NULL;
-static GetInterfaceInfoFunc gGetInterfaceInfo = NULL;
-static GetAdaptersInfoFunc gGetAdaptersInfo = NULL;
-static GetNetworkParamsFunc gGetNetworkParams = NULL;
-static GetIcmpStatisticsFunc gGetIcmpStatistics = NULL;
-static GetIpStatisticsFunc gGetIpStatistics = NULL;
-static GetTcpStatisticsFunc gGetTcpStatistics = NULL;
-static GetUdpStatisticsFunc gGetUdpStatistics = NULL;
-static GetTcpTableFunc gGetTcpTable = NULL;
-static GetUdpTableFunc gGetUdpTable = NULL;
-static GetPerAdapterInfoFunc gGetPerAdapterInfo = NULL;
-static GetAdaptersAddressesFunc gGetAdaptersAddresses = NULL;
-static NotifyAddrChangeFunc gNotifyAddrChange = NULL;
-static CancelIPChangeNotifyFunc gCancelIPChangeNotify = NULL;
+static DWORD (WINAPI *pGetNumberOfInterfaces)(PDWORD);
+static DWORD (WINAPI *pGetIpAddrTable)(PMIB_IPADDRTABLE,PULONG,BOOL);
+static DWORD (WINAPI *pGetIfEntry)(PMIB_IFROW);
+static DWORD (WINAPI *pGetIfEntry2)(PMIB_IF_ROW2);
+static DWORD (WINAPI *pGetFriendlyIfIndex)(DWORD);
+static DWORD (WINAPI *pGetIfTable)(PMIB_IFTABLE,PULONG,BOOL);
+static DWORD (WINAPI *pGetIfTable2)(PMIB_IF_TABLE2*);
+static DWORD (WINAPI *pGetIpForwardTable)(PMIB_IPFORWARDTABLE,PULONG,BOOL);
+static DWORD (WINAPI *pGetIpNetTable)(PMIB_IPNETTABLE,PULONG,BOOL);
+static DWORD (WINAPI *pGetInterfaceInfo)(PIP_INTERFACE_INFO,PULONG);
+static DWORD (WINAPI *pGetAdaptersInfo)(PIP_ADAPTER_INFO,PULONG);
+static DWORD (WINAPI *pGetNetworkParams)(PFIXED_INFO,PULONG);
+static DWORD (WINAPI *pGetIcmpStatistics)(PMIB_ICMP);
+static DWORD (WINAPI *pGetIpStatistics)(PMIB_IPSTATS);
+static DWORD (WINAPI *pGetTcpStatistics)(PMIB_TCPSTATS);
+static DWORD (WINAPI *pGetUdpStatistics)(PMIB_UDPSTATS);
+static DWORD (WINAPI *pGetIcmpStatisticsEx)(PMIB_ICMP_EX,DWORD);
+static DWORD (WINAPI *pGetIpStatisticsEx)(PMIB_IPSTATS,DWORD);
+static DWORD (WINAPI *pGetTcpStatisticsEx)(PMIB_TCPSTATS,DWORD);
+static DWORD (WINAPI *pGetUdpStatisticsEx)(PMIB_UDPSTATS,DWORD);
+static DWORD (WINAPI *pGetTcpTable)(PMIB_TCPTABLE,PDWORD,BOOL);
+static DWORD (WINAPI *pGetUdpTable)(PMIB_UDPTABLE,PDWORD,BOOL);
+static DWORD (WINAPI *pGetPerAdapterInfo)(ULONG,PIP_PER_ADAPTER_INFO,PULONG);
+static DWORD (WINAPI *pGetAdaptersAddresses)(ULONG,ULONG,PVOID,PIP_ADAPTER_ADDRESSES,PULONG);
+static DWORD (WINAPI *pNotifyAddrChange)(PHANDLE,LPOVERLAPPED);
+static BOOL (WINAPI *pCancelIPChangeNotify)(LPOVERLAPPED);
+static DWORD (WINAPI *pGetExtendedTcpTable)(PVOID,PDWORD,BOOL,ULONG,TCP_TABLE_CLASS,ULONG);
+static DWORD (WINAPI *pGetExtendedUdpTable)(PVOID,PDWORD,BOOL,ULONG,UDP_TABLE_CLASS,ULONG);
+static DWORD (WINAPI *pSetTcpEntry)(PMIB_TCPROW);
+static HANDLE(WINAPI *pIcmpCreateFile)(VOID);
+static DWORD (WINAPI *pIcmpSendEcho)(HANDLE,IPAddr,LPVOID,WORD,PIP_OPTION_INFORMATION,LPVOID,DWORD,DWORD);
+static DWORD (WINAPI *pCreateSortedAddressPairs)(const PSOCKADDR_IN6,ULONG,const PSOCKADDR_IN6,ULONG,ULONG,
+ PSOCKADDR_IN6_PAIR*,ULONG*);
+static void (WINAPI *pFreeMibTable)(void*);
+static DWORD (WINAPI *pConvertInterfaceGuidToLuid)(const GUID*,NET_LUID*);
+static DWORD (WINAPI *pConvertInterfaceIndexToLuid)(NET_IFINDEX,NET_LUID*);
+static DWORD (WINAPI *pConvertInterfaceLuidToGuid)(const NET_LUID*,GUID*);
+static DWORD (WINAPI *pConvertInterfaceLuidToIndex)(const NET_LUID*,NET_IFINDEX*);
+static DWORD (WINAPI *pConvertInterfaceLuidToNameW)(const NET_LUID*,WCHAR*,SIZE_T);
+static DWORD (WINAPI *pConvertInterfaceLuidToNameA)(const NET_LUID*,char*,SIZE_T);
+static DWORD (WINAPI *pConvertInterfaceNameToLuidA)(const char*,NET_LUID*);
+static DWORD (WINAPI *pConvertInterfaceNameToLuidW)(const WCHAR*,NET_LUID*);
static void loadIPHlpApi(void)
{
hLibrary = LoadLibraryA("iphlpapi.dll");
if (hLibrary) {
- gGetNumberOfInterfaces = (GetNumberOfInterfacesFunc)GetProcAddress(
- hLibrary, "GetNumberOfInterfaces");
- gGetIpAddrTable = (GetIpAddrTableFunc)GetProcAddress(
- hLibrary, "GetIpAddrTable");
- gGetIfEntry = (GetIfEntryFunc)GetProcAddress(
- hLibrary, "GetIfEntry");
- gGetFriendlyIfIndex = (GetFriendlyIfIndexFunc)GetProcAddress(
- hLibrary, "GetFriendlyIfIndex");
- gGetIfTable = (GetIfTableFunc)GetProcAddress(
- hLibrary, "GetIfTable");
- gGetIpForwardTable = (GetIpForwardTableFunc)GetProcAddress(
- hLibrary, "GetIpForwardTable");
- gGetIpNetTable = (GetIpNetTableFunc)GetProcAddress(
- hLibrary, "GetIpNetTable");
- gGetInterfaceInfo = (GetInterfaceInfoFunc)GetProcAddress(
- hLibrary, "GetInterfaceInfo");
- gGetAdaptersInfo = (GetAdaptersInfoFunc)GetProcAddress(
- hLibrary, "GetAdaptersInfo");
- gGetNetworkParams = (GetNetworkParamsFunc)GetProcAddress(
- hLibrary, "GetNetworkParams");
- gGetIcmpStatistics = (GetIcmpStatisticsFunc)GetProcAddress(
- hLibrary, "GetIcmpStatistics");
- gGetIpStatistics = (GetIpStatisticsFunc)GetProcAddress(
- hLibrary, "GetIpStatistics");
- gGetTcpStatistics = (GetTcpStatisticsFunc)GetProcAddress(
- hLibrary, "GetTcpStatistics");
- gGetUdpStatistics = (GetUdpStatisticsFunc)GetProcAddress(
- hLibrary, "GetUdpStatistics");
- gGetTcpTable = (GetTcpTableFunc)GetProcAddress(
- hLibrary, "GetTcpTable");
- gGetUdpTable = (GetUdpTableFunc)GetProcAddress(
- hLibrary, "GetUdpTable");
- gGetPerAdapterInfo = (GetPerAdapterInfoFunc)GetProcAddress(hLibrary, "GetPerAdapterInfo");
- gGetAdaptersAddresses = (GetAdaptersAddressesFunc)GetProcAddress(hLibrary, "GetAdaptersAddresses");
- gNotifyAddrChange = (NotifyAddrChangeFunc)GetProcAddress(
- hLibrary, "NotifyAddrChange");
- gCancelIPChangeNotify = (CancelIPChangeNotifyFunc)GetProcAddress(
- hLibrary, "CancelIPChangeNotify");
+ pGetNumberOfInterfaces = (void *)GetProcAddress(hLibrary, "GetNumberOfInterfaces");
+ pGetIpAddrTable = (void *)GetProcAddress(hLibrary, "GetIpAddrTable");
+ pGetIfEntry = (void *)GetProcAddress(hLibrary, "GetIfEntry");
+ pGetIfEntry2 = (void *)GetProcAddress(hLibrary, "GetIfEntry2");
+ pGetFriendlyIfIndex = (void *)GetProcAddress(hLibrary, "GetFriendlyIfIndex");
+ pGetIfTable = (void *)GetProcAddress(hLibrary, "GetIfTable");
+ pGetIfTable2 = (void *)GetProcAddress(hLibrary, "GetIfTable2");
+ pGetIpForwardTable = (void *)GetProcAddress(hLibrary, "GetIpForwardTable");
+ pGetIpNetTable = (void *)GetProcAddress(hLibrary, "GetIpNetTable");
+ pGetInterfaceInfo = (void *)GetProcAddress(hLibrary, "GetInterfaceInfo");
+ pGetAdaptersInfo = (void *)GetProcAddress(hLibrary, "GetAdaptersInfo");
+ pGetNetworkParams = (void *)GetProcAddress(hLibrary, "GetNetworkParams");
+ pGetIcmpStatistics = (void *)GetProcAddress(hLibrary, "GetIcmpStatistics");
+ pGetIpStatistics = (void *)GetProcAddress(hLibrary, "GetIpStatistics");
+ pGetTcpStatistics = (void *)GetProcAddress(hLibrary, "GetTcpStatistics");
+ pGetUdpStatistics = (void *)GetProcAddress(hLibrary, "GetUdpStatistics");
+ pGetIcmpStatisticsEx = (void *)GetProcAddress(hLibrary, "GetIcmpStatisticsEx");
+ pGetIpStatisticsEx = (void *)GetProcAddress(hLibrary, "GetIpStatisticsEx");
+ pGetTcpStatisticsEx = (void *)GetProcAddress(hLibrary, "GetTcpStatisticsEx");
+ pGetUdpStatisticsEx = (void *)GetProcAddress(hLibrary, "GetUdpStatisticsEx");
+ pGetTcpTable = (void *)GetProcAddress(hLibrary, "GetTcpTable");
+ pGetUdpTable = (void *)GetProcAddress(hLibrary, "GetUdpTable");
+ pGetPerAdapterInfo = (void *)GetProcAddress(hLibrary, "GetPerAdapterInfo");
+ pGetAdaptersAddresses = (void *)GetProcAddress(hLibrary, "GetAdaptersAddresses");
+ pNotifyAddrChange = (void *)GetProcAddress(hLibrary, "NotifyAddrChange");
+ pCancelIPChangeNotify = (void *)GetProcAddress(hLibrary, "CancelIPChangeNotify");
+ pGetExtendedTcpTable = (void *)GetProcAddress(hLibrary, "GetExtendedTcpTable");
+ pGetExtendedUdpTable = (void *)GetProcAddress(hLibrary, "GetExtendedUdpTable");
+ pSetTcpEntry = (void *)GetProcAddress(hLibrary, "SetTcpEntry");
+ pIcmpCreateFile = (void *)GetProcAddress(hLibrary, "IcmpCreateFile");
+ pIcmpSendEcho = (void *)GetProcAddress(hLibrary, "IcmpSendEcho");
+ pCreateSortedAddressPairs = (void *)GetProcAddress(hLibrary, "CreateSortedAddressPairs");
+ pFreeMibTable = (void *)GetProcAddress(hLibrary, "FreeMibTable");
+ pConvertInterfaceGuidToLuid = (void *)GetProcAddress(hLibrary, "ConvertInterfaceGuidToLuid");
+ pConvertInterfaceIndexToLuid = (void *)GetProcAddress(hLibrary, "ConvertInterfaceIndexToLuid");
+ pConvertInterfaceLuidToGuid = (void *)GetProcAddress(hLibrary, "ConvertInterfaceLuidToGuid");
+ pConvertInterfaceLuidToIndex = (void *)GetProcAddress(hLibrary, "ConvertInterfaceLuidToIndex");
+ pConvertInterfaceLuidToNameA = (void *)GetProcAddress(hLibrary, "ConvertInterfaceLuidToNameA");
+ pConvertInterfaceLuidToNameW = (void *)GetProcAddress(hLibrary, "ConvertInterfaceLuidToNameW");
+ pConvertInterfaceNameToLuidA = (void *)GetProcAddress(hLibrary, "ConvertInterfaceNameToLuidA");
+ pConvertInterfaceNameToLuidW = (void *)GetProcAddress(hLibrary, "ConvertInterfaceNameToLuidW");
}
}
static void freeIPHlpApi(void)
{
- if (hLibrary) {
- gGetNumberOfInterfaces = NULL;
- gGetIpAddrTable = NULL;
- gGetIfEntry = NULL;
- gGetFriendlyIfIndex = NULL;
- gGetIfTable = NULL;
- gGetIpForwardTable = NULL;
- gGetIpNetTable = NULL;
- gGetInterfaceInfo = NULL;
- gGetAdaptersInfo = NULL;
- gGetNetworkParams = NULL;
- gGetIcmpStatistics = NULL;
- gGetIpStatistics = NULL;
- gGetTcpStatistics = NULL;
- gGetUdpStatistics = NULL;
- gGetTcpTable = NULL;
- gGetUdpTable = NULL;
- gNotifyAddrChange = NULL;
- gCancelIPChangeNotify = NULL;
FreeLibrary(hLibrary);
- hLibrary = NULL;
- }
}
/* replacement for inet_ntoa */
return buffer;
}
+static inline const char* debugstr_longlong(ULONGLONG ll)
+{
+ static char string[17];
+ if (sizeof(ll) > sizeof(unsigned long) && ll >> 32)
+ sprintf(string, "%lx%08lx", (unsigned long)(ll >> 32), (unsigned long)ll);
+ else
+ sprintf(string, "%lx", (unsigned long)ll);
+ return string;
+}
+
/*
still-to-be-tested 98-only functions:
GetUniDirectionalAdapterInfo
static void testGetNumberOfInterfaces(void)
{
- if (gGetNumberOfInterfaces) {
+ if (pGetNumberOfInterfaces) {
DWORD apiReturn, numInterfaces;
/* Crashes on Vista */
if (0) {
- apiReturn = gGetNumberOfInterfaces(NULL);
+ apiReturn = pGetNumberOfInterfaces(NULL);
if (apiReturn == ERROR_NOT_SUPPORTED)
return;
ok(apiReturn == ERROR_INVALID_PARAMETER,
apiReturn);
}
- apiReturn = gGetNumberOfInterfaces(&numInterfaces);
+ apiReturn = pGetNumberOfInterfaces(&numInterfaces);
if (apiReturn == ERROR_NOT_SUPPORTED) {
skip("GetNumberOfInterfaces is not supported\n");
return;
static void testGetIfEntry(DWORD index)
{
- if (gGetIfEntry) {
+ if (pGetIfEntry) {
DWORD apiReturn;
MIB_IFROW row;
memset(&row, 0, sizeof(row));
- apiReturn = gGetIfEntry(NULL);
+ apiReturn = pGetIfEntry(NULL);
if (apiReturn == ERROR_NOT_SUPPORTED) {
skip("GetIfEntry is not supported\n");
return;
"GetIfEntry(NULL) returned %d, expected ERROR_INVALID_PARAMETER\n",
apiReturn);
row.dwIndex = -1; /* hope that's always bogus! */
- apiReturn = gGetIfEntry(&row);
+ apiReturn = pGetIfEntry(&row);
ok(apiReturn == ERROR_INVALID_DATA ||
apiReturn == ERROR_FILE_NOT_FOUND /* Vista */,
"GetIfEntry(bogus row) returned %d, expected ERROR_INVALID_DATA or ERROR_FILE_NOT_FOUND\n",
apiReturn);
row.dwIndex = index;
- apiReturn = gGetIfEntry(&row);
+ apiReturn = pGetIfEntry(&row);
ok(apiReturn == NO_ERROR,
"GetIfEntry returned %d, expected NO_ERROR\n", apiReturn);
}
static void testGetIpAddrTable(void)
{
- if (gGetIpAddrTable) {
+ if (pGetIpAddrTable) {
DWORD apiReturn;
ULONG dwSize = 0;
- apiReturn = gGetIpAddrTable(NULL, NULL, FALSE);
+ apiReturn = pGetIpAddrTable(NULL, NULL, FALSE);
if (apiReturn == ERROR_NOT_SUPPORTED) {
skip("GetIpAddrTable is not supported\n");
return;
ok(apiReturn == ERROR_INVALID_PARAMETER,
"GetIpAddrTable(NULL, NULL, FALSE) returned %d, expected ERROR_INVALID_PARAMETER\n",
apiReturn);
- apiReturn = gGetIpAddrTable(NULL, &dwSize, FALSE);
+ apiReturn = pGetIpAddrTable(NULL, &dwSize, FALSE);
ok(apiReturn == ERROR_INSUFFICIENT_BUFFER,
"GetIpAddrTable(NULL, &dwSize, FALSE) returned %d, expected ERROR_INSUFFICIENT_BUFFER\n",
apiReturn);
if (apiReturn == ERROR_INSUFFICIENT_BUFFER) {
PMIB_IPADDRTABLE buf = HeapAlloc(GetProcessHeap(), 0, dwSize);
- apiReturn = gGetIpAddrTable(buf, &dwSize, FALSE);
+ apiReturn = pGetIpAddrTable(buf, &dwSize, FALSE);
ok(apiReturn == NO_ERROR,
"GetIpAddrTable(buf, &dwSize, FALSE) returned %d, expected NO_ERROR\n",
apiReturn);
if (apiReturn == NO_ERROR && buf->dwNumEntries)
+ {
+ int i;
testGetIfEntry(buf->table[0].dwIndex);
+ for (i = 0; i < buf->dwNumEntries; i++)
+ {
+ ok (buf->table[i].wType != 0, "Test[%d]: expected wType > 0\n", i);
+ trace("Entry[%d]: addr %s, dwIndex %u, wType 0x%x\n", i,
+ ntoa(buf->table[i].dwAddr), buf->table[i].dwIndex, buf->table[i].wType);
+ }
+ }
HeapFree(GetProcessHeap(), 0, buf);
}
}
static void testGetIfTable(void)
{
- if (gGetIfTable) {
+ if (pGetIfTable) {
DWORD apiReturn;
ULONG dwSize = 0;
- apiReturn = gGetIfTable(NULL, NULL, FALSE);
+ apiReturn = pGetIfTable(NULL, NULL, FALSE);
if (apiReturn == ERROR_NOT_SUPPORTED) {
skip("GetIfTable is not supported\n");
return;
ok(apiReturn == ERROR_INVALID_PARAMETER,
"GetIfTable(NULL, NULL, FALSE) returned %d, expected ERROR_INVALID_PARAMETER\n",
apiReturn);
- apiReturn = gGetIfTable(NULL, &dwSize, FALSE);
+ apiReturn = pGetIfTable(NULL, &dwSize, FALSE);
ok(apiReturn == ERROR_INSUFFICIENT_BUFFER,
"GetIfTable(NULL, &dwSize, FALSE) returned %d, expected ERROR_INSUFFICIENT_BUFFER\n",
apiReturn);
if (apiReturn == ERROR_INSUFFICIENT_BUFFER) {
PMIB_IFTABLE buf = HeapAlloc(GetProcessHeap(), 0, dwSize);
- apiReturn = gGetIfTable(buf, &dwSize, FALSE);
+ apiReturn = pGetIfTable(buf, &dwSize, FALSE);
ok(apiReturn == NO_ERROR,
"GetIfTable(buf, &dwSize, FALSE) returned %d, expected NO_ERROR\n\n",
apiReturn);
static void testGetIpForwardTable(void)
{
- if (gGetIpForwardTable) {
+ if (pGetIpForwardTable) {
DWORD apiReturn;
ULONG dwSize = 0;
- apiReturn = gGetIpForwardTable(NULL, NULL, FALSE);
+ apiReturn = pGetIpForwardTable(NULL, NULL, FALSE);
if (apiReturn == ERROR_NOT_SUPPORTED) {
skip("GetIpForwardTable is not supported\n");
return;
ok(apiReturn == ERROR_INVALID_PARAMETER,
"GetIpForwardTable(NULL, NULL, FALSE) returned %d, expected ERROR_INVALID_PARAMETER\n",
apiReturn);
- apiReturn = gGetIpForwardTable(NULL, &dwSize, FALSE);
+ apiReturn = pGetIpForwardTable(NULL, &dwSize, FALSE);
ok(apiReturn == ERROR_INSUFFICIENT_BUFFER,
"GetIpForwardTable(NULL, &dwSize, FALSE) returned %d, expected ERROR_INSUFFICIENT_BUFFER\n",
apiReturn);
if (apiReturn == ERROR_INSUFFICIENT_BUFFER) {
PMIB_IPFORWARDTABLE buf = HeapAlloc(GetProcessHeap(), 0, dwSize);
- apiReturn = gGetIpForwardTable(buf, &dwSize, FALSE);
+ apiReturn = pGetIpForwardTable(buf, &dwSize, FALSE);
ok(apiReturn == NO_ERROR,
"GetIpForwardTable(buf, &dwSize, FALSE) returned %d, expected NO_ERROR\n",
apiReturn);
trace( "IP forward table: %u entries\n", buf->dwNumEntries );
for (i = 0; i < buf->dwNumEntries; i++)
{
- char buffer[40];
+ char buffer[100];
sprintf( buffer, "dest %s", ntoa( buf->table[i].dwForwardDest ));
sprintf( buffer + strlen(buffer), " mask %s", ntoa( buf->table[i].dwForwardMask ));
trace( "%u: %s gw %s if %u type %u\n", i, buffer,
ntoa( buf->table[i].dwForwardNextHop ),
- buf->table[i].dwForwardIfIndex, buf->table[i].dwForwardType );
+ buf->table[i].dwForwardIfIndex, U1(buf->table[i]).dwForwardType );
}
}
HeapFree(GetProcessHeap(), 0, buf);
static void testGetIpNetTable(void)
{
- if (gGetIpNetTable) {
+ if (pGetIpNetTable) {
DWORD apiReturn;
ULONG dwSize = 0;
- apiReturn = gGetIpNetTable(NULL, NULL, FALSE);
+ apiReturn = pGetIpNetTable(NULL, NULL, FALSE);
if (apiReturn == ERROR_NOT_SUPPORTED) {
skip("GetIpNetTable is not supported\n");
return;
ok(apiReturn == ERROR_INVALID_PARAMETER,
"GetIpNetTable(NULL, NULL, FALSE) returned %d, expected ERROR_INVALID_PARAMETER\n",
apiReturn);
- apiReturn = gGetIpNetTable(NULL, &dwSize, FALSE);
+ apiReturn = pGetIpNetTable(NULL, &dwSize, FALSE);
ok(apiReturn == ERROR_NO_DATA || apiReturn == ERROR_INSUFFICIENT_BUFFER,
"GetIpNetTable(NULL, &dwSize, FALSE) returned %d, expected ERROR_NO_DATA or ERROR_INSUFFICIENT_BUFFER\n",
apiReturn);
else if (apiReturn == ERROR_INSUFFICIENT_BUFFER) {
PMIB_IPNETTABLE buf = HeapAlloc(GetProcessHeap(), 0, dwSize);
- apiReturn = gGetIpNetTable(buf, &dwSize, FALSE);
+ apiReturn = pGetIpNetTable(buf, &dwSize, FALSE);
ok(apiReturn == NO_ERROR ||
apiReturn == ERROR_NO_DATA, /* empty ARP table's okay */
"GetIpNetTable(buf, &dwSize, FALSE) returned %d, expected NO_ERROR\n",
for (i = 0; i < buf->dwNumEntries; i++)
{
trace( "%u: idx %u type %u addr %s phys",
- i, buf->table[i].dwIndex, buf->table[i].dwType, ntoa( buf->table[i].dwAddr ));
+ i, buf->table[i].dwIndex, U(buf->table[i]).dwType, ntoa( buf->table[i].dwAddr ));
for (j = 0; j < buf->table[i].dwPhysAddrLen; j++)
printf( " %02x", buf->table[i].bPhysAddr[j] );
printf( "\n" );
static void testGetIcmpStatistics(void)
{
- if (gGetIcmpStatistics) {
+ if (pGetIcmpStatistics) {
DWORD apiReturn;
MIB_ICMP stats;
/* Crashes on Vista */
if (0) {
- apiReturn = gGetIcmpStatistics(NULL);
+ apiReturn = pGetIcmpStatistics(NULL);
if (apiReturn == ERROR_NOT_SUPPORTED)
return;
ok(apiReturn == ERROR_INVALID_PARAMETER,
apiReturn);
}
- apiReturn = gGetIcmpStatistics(&stats);
+ apiReturn = pGetIcmpStatistics(&stats);
if (apiReturn == ERROR_NOT_SUPPORTED)
{
skip("GetIcmpStatistics is not supported\n");
static void testGetIpStatistics(void)
{
- if (gGetIpStatistics) {
+ if (pGetIpStatistics) {
DWORD apiReturn;
MIB_IPSTATS stats;
- apiReturn = gGetIpStatistics(NULL);
+ apiReturn = pGetIpStatistics(NULL);
if (apiReturn == ERROR_NOT_SUPPORTED) {
skip("GetIpStatistics is not supported\n");
return;
ok(apiReturn == ERROR_INVALID_PARAMETER,
"GetIpStatistics(NULL) returned %d, expected ERROR_INVALID_PARAMETER\n",
apiReturn);
- apiReturn = gGetIpStatistics(&stats);
+ apiReturn = pGetIpStatistics(&stats);
ok(apiReturn == NO_ERROR,
"GetIpStatistics returned %d, expected NO_ERROR\n", apiReturn);
if (apiReturn == NO_ERROR && winetest_debug > 1)
{
trace( "IP stats:\n" );
- trace( " dwForwarding: %u\n", stats.dwForwarding );
+ trace( " dwForwarding: %u\n", U(stats).dwForwarding );
trace( " dwDefaultTTL: %u\n", stats.dwDefaultTTL );
trace( " dwInReceives: %u\n", stats.dwInReceives );
trace( " dwInHdrErrors: %u\n", stats.dwInHdrErrors );
static void testGetTcpStatistics(void)
{
- if (gGetTcpStatistics) {
+ if (pGetTcpStatistics) {
DWORD apiReturn;
MIB_TCPSTATS stats;
- apiReturn = gGetTcpStatistics(NULL);
+ apiReturn = pGetTcpStatistics(NULL);
if (apiReturn == ERROR_NOT_SUPPORTED) {
skip("GetTcpStatistics is not supported\n");
return;
ok(apiReturn == ERROR_INVALID_PARAMETER,
"GetTcpStatistics(NULL) returned %d, expected ERROR_INVALID_PARAMETER\n",
apiReturn);
- apiReturn = gGetTcpStatistics(&stats);
+ apiReturn = pGetTcpStatistics(&stats);
ok(apiReturn == NO_ERROR,
"GetTcpStatistics returned %d, expected NO_ERROR\n", apiReturn);
if (apiReturn == NO_ERROR && winetest_debug > 1)
{
trace( "TCP stats:\n" );
- trace( " dwRtoAlgorithm: %u\n", stats.dwRtoAlgorithm );
+ trace( " dwRtoAlgorithm: %u\n", U(stats).dwRtoAlgorithm );
trace( " dwRtoMin: %u\n", stats.dwRtoMin );
trace( " dwRtoMax: %u\n", stats.dwRtoMax );
trace( " dwMaxConn: %u\n", stats.dwMaxConn );
static void testGetUdpStatistics(void)
{
- if (gGetUdpStatistics) {
+ if (pGetUdpStatistics) {
DWORD apiReturn;
MIB_UDPSTATS stats;
- apiReturn = gGetUdpStatistics(NULL);
+ apiReturn = pGetUdpStatistics(NULL);
if (apiReturn == ERROR_NOT_SUPPORTED) {
skip("GetUdpStatistics is not supported\n");
return;
ok(apiReturn == ERROR_INVALID_PARAMETER,
"GetUdpStatistics(NULL) returned %d, expected ERROR_INVALID_PARAMETER\n",
apiReturn);
- apiReturn = gGetUdpStatistics(&stats);
+ apiReturn = pGetUdpStatistics(&stats);
ok(apiReturn == NO_ERROR,
"GetUdpStatistics returned %d, expected NO_ERROR\n", apiReturn);
if (apiReturn == NO_ERROR && winetest_debug > 1)
}
}
+static void testGetIcmpStatisticsEx(void)
+{
+ DWORD apiReturn;
+ MIB_ICMP_EX stats;
+
+ if (!pGetIcmpStatisticsEx)
+ {
+ win_skip( "GetIcmpStatisticsEx not available\n" );
+ return;
+ }
+
+ /* Crashes on Vista */
+ if (1) {
+ apiReturn = pGetIcmpStatisticsEx(NULL, AF_INET);
+ ok(apiReturn == ERROR_INVALID_PARAMETER,
+ "GetIcmpStatisticsEx(NULL, AF_INET) returned %d, expected ERROR_INVALID_PARAMETER\n", apiReturn);
+ }
+
+ apiReturn = pGetIcmpStatisticsEx(&stats, AF_BAN);
+ ok(apiReturn == ERROR_INVALID_PARAMETER,
+ "GetIcmpStatisticsEx(&stats, AF_BAN) returned %d, expected ERROR_INVALID_PARAMETER\n", apiReturn);
+
+ apiReturn = pGetIcmpStatisticsEx(&stats, AF_INET);
+ ok(apiReturn == NO_ERROR, "GetIcmpStatisticsEx returned %d, expected NO_ERROR\n", apiReturn);
+ if (apiReturn == NO_ERROR && winetest_debug > 1)
+ {
+ INT i;
+ trace( "ICMP IPv4 Ex stats: %8s %8s\n", "in", "out" );
+ trace( " dwMsgs: %8u %8u\n", stats.icmpInStats.dwMsgs, stats.icmpOutStats.dwMsgs );
+ trace( " dwErrors: %8u %8u\n", stats.icmpInStats.dwErrors, stats.icmpOutStats.dwErrors );
+ for (i = 0; i < 256; i++)
+ trace( " rgdwTypeCount[%3i]: %8u %8u\n", i, stats.icmpInStats.rgdwTypeCount[i], stats.icmpOutStats.rgdwTypeCount[i] );
+ }
+
+ apiReturn = pGetIcmpStatisticsEx(&stats, AF_INET6);
+ ok(apiReturn == NO_ERROR || broken(apiReturn == ERROR_NOT_SUPPORTED),
+ "GetIcmpStatisticsEx returned %d, expected NO_ERROR\n", apiReturn);
+ if (apiReturn == NO_ERROR && winetest_debug > 1)
+ {
+ INT i;
+ trace( "ICMP IPv6 Ex stats: %8s %8s\n", "in", "out" );
+ trace( " dwMsgs: %8u %8u\n", stats.icmpInStats.dwMsgs, stats.icmpOutStats.dwMsgs );
+ trace( " dwErrors: %8u %8u\n", stats.icmpInStats.dwErrors, stats.icmpOutStats.dwErrors );
+ for (i = 0; i < 256; i++)
+ trace( " rgdwTypeCount[%3i]: %8u %8u\n", i, stats.icmpInStats.rgdwTypeCount[i], stats.icmpOutStats.rgdwTypeCount[i] );
+ }
+}
+
+static void testGetIpStatisticsEx(void)
+{
+ DWORD apiReturn;
+ MIB_IPSTATS stats;
+
+ if (!pGetIpStatisticsEx)
+ {
+ win_skip( "GetIpStatisticsEx not available\n" );
+ return;
+ }
+
+ apiReturn = pGetIpStatisticsEx(NULL, AF_INET);
+ ok(apiReturn == ERROR_INVALID_PARAMETER,
+ "GetIpStatisticsEx(NULL, AF_INET) returned %d, expected ERROR_INVALID_PARAMETER\n", apiReturn);
+
+ apiReturn = pGetIpStatisticsEx(&stats, AF_BAN);
+ ok(apiReturn == ERROR_INVALID_PARAMETER,
+ "GetIpStatisticsEx(&stats, AF_BAN) returned %d, expected ERROR_INVALID_PARAMETER\n", apiReturn);
+
+ apiReturn = pGetIpStatisticsEx(&stats, AF_INET);
+ ok(apiReturn == NO_ERROR, "GetIpStatisticsEx returned %d, expected NO_ERROR\n", apiReturn);
+ if (apiReturn == NO_ERROR && winetest_debug > 1)
+ {
+ trace( "IP IPv4 Ex stats:\n" );
+ trace( " dwForwarding: %u\n", U(stats).dwForwarding );
+ trace( " dwDefaultTTL: %u\n", stats.dwDefaultTTL );
+ trace( " dwInReceives: %u\n", stats.dwInReceives );
+ trace( " dwInHdrErrors: %u\n", stats.dwInHdrErrors );
+ trace( " dwInAddrErrors: %u\n", stats.dwInAddrErrors );
+ trace( " dwForwDatagrams: %u\n", stats.dwForwDatagrams );
+ trace( " dwInUnknownProtos: %u\n", stats.dwInUnknownProtos );
+ trace( " dwInDiscards: %u\n", stats.dwInDiscards );
+ trace( " dwInDelivers: %u\n", stats.dwInDelivers );
+ trace( " dwOutRequests: %u\n", stats.dwOutRequests );
+ trace( " dwRoutingDiscards: %u\n", stats.dwRoutingDiscards );
+ trace( " dwOutDiscards: %u\n", stats.dwOutDiscards );
+ trace( " dwOutNoRoutes: %u\n", stats.dwOutNoRoutes );
+ trace( " dwReasmTimeout: %u\n", stats.dwReasmTimeout );
+ trace( " dwReasmReqds: %u\n", stats.dwReasmReqds );
+ trace( " dwReasmOks: %u\n", stats.dwReasmOks );
+ trace( " dwReasmFails: %u\n", stats.dwReasmFails );
+ trace( " dwFragOks: %u\n", stats.dwFragOks );
+ trace( " dwFragFails: %u\n", stats.dwFragFails );
+ trace( " dwFragCreates: %u\n", stats.dwFragCreates );
+ trace( " dwNumIf: %u\n", stats.dwNumIf );
+ trace( " dwNumAddr: %u\n", stats.dwNumAddr );
+ trace( " dwNumRoutes: %u\n", stats.dwNumRoutes );
+ }
+
+ apiReturn = pGetIpStatisticsEx(&stats, AF_INET6);
+ ok(apiReturn == NO_ERROR || broken(apiReturn == ERROR_NOT_SUPPORTED),
+ "GetIpStatisticsEx returned %d, expected NO_ERROR\n", apiReturn);
+ if (apiReturn == NO_ERROR && winetest_debug > 1)
+ {
+ trace( "IP IPv6 Ex stats:\n" );
+ trace( " dwForwarding: %u\n", U(stats).dwForwarding );
+ trace( " dwDefaultTTL: %u\n", stats.dwDefaultTTL );
+ trace( " dwInReceives: %u\n", stats.dwInReceives );
+ trace( " dwInHdrErrors: %u\n", stats.dwInHdrErrors );
+ trace( " dwInAddrErrors: %u\n", stats.dwInAddrErrors );
+ trace( " dwForwDatagrams: %u\n", stats.dwForwDatagrams );
+ trace( " dwInUnknownProtos: %u\n", stats.dwInUnknownProtos );
+ trace( " dwInDiscards: %u\n", stats.dwInDiscards );
+ trace( " dwInDelivers: %u\n", stats.dwInDelivers );
+ trace( " dwOutRequests: %u\n", stats.dwOutRequests );
+ trace( " dwRoutingDiscards: %u\n", stats.dwRoutingDiscards );
+ trace( " dwOutDiscards: %u\n", stats.dwOutDiscards );
+ trace( " dwOutNoRoutes: %u\n", stats.dwOutNoRoutes );
+ trace( " dwReasmTimeout: %u\n", stats.dwReasmTimeout );
+ trace( " dwReasmReqds: %u\n", stats.dwReasmReqds );
+ trace( " dwReasmOks: %u\n", stats.dwReasmOks );
+ trace( " dwReasmFails: %u\n", stats.dwReasmFails );
+ trace( " dwFragOks: %u\n", stats.dwFragOks );
+ trace( " dwFragFails: %u\n", stats.dwFragFails );
+ trace( " dwFragCreates: %u\n", stats.dwFragCreates );
+ trace( " dwNumIf: %u\n", stats.dwNumIf );
+ trace( " dwNumAddr: %u\n", stats.dwNumAddr );
+ trace( " dwNumRoutes: %u\n", stats.dwNumRoutes );
+ }
+}
+
+static void testGetTcpStatisticsEx(void)
+{
+ DWORD apiReturn;
+ MIB_TCPSTATS stats;
+
+ if (!pGetTcpStatisticsEx)
+ {
+ win_skip( "GetTcpStatisticsEx not available\n" );
+ return;
+ }
+
+ apiReturn = pGetTcpStatisticsEx(NULL, AF_INET);
+ ok(apiReturn == ERROR_INVALID_PARAMETER,
+ "GetTcpStatisticsEx(NULL, AF_INET); returned %d, expected ERROR_INVALID_PARAMETER\n", apiReturn);
+
+ apiReturn = pGetTcpStatisticsEx(&stats, AF_BAN);
+ ok(apiReturn == ERROR_INVALID_PARAMETER || apiReturn == ERROR_NOT_SUPPORTED,
+ "GetTcpStatisticsEx(&stats, AF_BAN) returned %d, expected ERROR_INVALID_PARAMETER\n", apiReturn);
+
+ apiReturn = pGetTcpStatisticsEx(&stats, AF_INET);
+ ok(apiReturn == NO_ERROR, "GetTcpStatisticsEx returned %d, expected NO_ERROR\n", apiReturn);
+ if (apiReturn == NO_ERROR && winetest_debug > 1)
+ {
+ trace( "TCP IPv4 Ex stats:\n" );
+ trace( " dwRtoAlgorithm: %u\n", U(stats).dwRtoAlgorithm );
+ trace( " dwRtoMin: %u\n", stats.dwRtoMin );
+ trace( " dwRtoMax: %u\n", stats.dwRtoMax );
+ trace( " dwMaxConn: %u\n", stats.dwMaxConn );
+ trace( " dwActiveOpens: %u\n", stats.dwActiveOpens );
+ trace( " dwPassiveOpens: %u\n", stats.dwPassiveOpens );
+ trace( " dwAttemptFails: %u\n", stats.dwAttemptFails );
+ trace( " dwEstabResets: %u\n", stats.dwEstabResets );
+ trace( " dwCurrEstab: %u\n", stats.dwCurrEstab );
+ trace( " dwInSegs: %u\n", stats.dwInSegs );
+ trace( " dwOutSegs: %u\n", stats.dwOutSegs );
+ trace( " dwRetransSegs: %u\n", stats.dwRetransSegs );
+ trace( " dwInErrs: %u\n", stats.dwInErrs );
+ trace( " dwOutRsts: %u\n", stats.dwOutRsts );
+ trace( " dwNumConns: %u\n", stats.dwNumConns );
+ }
+
+ apiReturn = pGetTcpStatisticsEx(&stats, AF_INET6);
+ todo_wine ok(apiReturn == NO_ERROR || broken(apiReturn == ERROR_NOT_SUPPORTED),
+ "GetTcpStatisticsEx returned %d, expected NO_ERROR\n", apiReturn);
+ if (apiReturn == NO_ERROR && winetest_debug > 1)
+ {
+ trace( "TCP IPv6 Ex stats:\n" );
+ trace( " dwRtoAlgorithm: %u\n", U(stats).dwRtoAlgorithm );
+ trace( " dwRtoMin: %u\n", stats.dwRtoMin );
+ trace( " dwRtoMax: %u\n", stats.dwRtoMax );
+ trace( " dwMaxConn: %u\n", stats.dwMaxConn );
+ trace( " dwActiveOpens: %u\n", stats.dwActiveOpens );
+ trace( " dwPassiveOpens: %u\n", stats.dwPassiveOpens );
+ trace( " dwAttemptFails: %u\n", stats.dwAttemptFails );
+ trace( " dwEstabResets: %u\n", stats.dwEstabResets );
+ trace( " dwCurrEstab: %u\n", stats.dwCurrEstab );
+ trace( " dwInSegs: %u\n", stats.dwInSegs );
+ trace( " dwOutSegs: %u\n", stats.dwOutSegs );
+ trace( " dwRetransSegs: %u\n", stats.dwRetransSegs );
+ trace( " dwInErrs: %u\n", stats.dwInErrs );
+ trace( " dwOutRsts: %u\n", stats.dwOutRsts );
+ trace( " dwNumConns: %u\n", stats.dwNumConns );
+ }
+}
+
+static void testGetUdpStatisticsEx(void)
+{
+ DWORD apiReturn;
+ MIB_UDPSTATS stats;
+
+ if (!pGetUdpStatisticsEx)
+ {
+ win_skip( "GetUdpStatisticsEx not available\n" );
+ return;
+ }
+
+ apiReturn = pGetUdpStatisticsEx(NULL, AF_INET);
+ ok(apiReturn == ERROR_INVALID_PARAMETER,
+ "GetUdpStatisticsEx(NULL, AF_INET); returned %d, expected ERROR_INVALID_PARAMETER\n", apiReturn);
+
+ apiReturn = pGetUdpStatisticsEx(&stats, AF_BAN);
+ ok(apiReturn == ERROR_INVALID_PARAMETER || apiReturn == ERROR_NOT_SUPPORTED,
+ "GetUdpStatisticsEx(&stats, AF_BAN) returned %d, expected ERROR_INVALID_PARAMETER\n", apiReturn);
+
+ apiReturn = pGetUdpStatisticsEx(&stats, AF_INET);
+ ok(apiReturn == NO_ERROR, "GetUdpStatisticsEx returned %d, expected NO_ERROR\n", apiReturn);
+ if (apiReturn == NO_ERROR && winetest_debug > 1)
+ {
+ trace( "UDP IPv4 Ex stats:\n" );
+ trace( " dwInDatagrams: %u\n", stats.dwInDatagrams );
+ trace( " dwNoPorts: %u\n", stats.dwNoPorts );
+ trace( " dwInErrors: %u\n", stats.dwInErrors );
+ trace( " dwOutDatagrams: %u\n", stats.dwOutDatagrams );
+ trace( " dwNumAddrs: %u\n", stats.dwNumAddrs );
+ }
+
+ apiReturn = pGetUdpStatisticsEx(&stats, AF_INET6);
+ ok(apiReturn == NO_ERROR || broken(apiReturn == ERROR_NOT_SUPPORTED),
+ "GetUdpStatisticsEx returned %d, expected NO_ERROR\n", apiReturn);
+ if (apiReturn == NO_ERROR && winetest_debug > 1)
+ {
+ trace( "UDP IPv6 Ex stats:\n" );
+ trace( " dwInDatagrams: %u\n", stats.dwInDatagrams );
+ trace( " dwNoPorts: %u\n", stats.dwNoPorts );
+ trace( " dwInErrors: %u\n", stats.dwInErrors );
+ trace( " dwOutDatagrams: %u\n", stats.dwOutDatagrams );
+ trace( " dwNumAddrs: %u\n", stats.dwNumAddrs );
+ }
+}
+
static void testGetTcpTable(void)
{
- if (gGetTcpTable) {
+ if (pGetTcpTable) {
DWORD apiReturn;
ULONG dwSize = 0;
- apiReturn = gGetTcpTable(NULL, &dwSize, FALSE);
+ apiReturn = pGetTcpTable(NULL, &dwSize, FALSE);
if (apiReturn == ERROR_NOT_SUPPORTED) {
skip("GetTcpTable is not supported\n");
return;
if (apiReturn == ERROR_INSUFFICIENT_BUFFER) {
PMIB_TCPTABLE buf = HeapAlloc(GetProcessHeap(), 0, dwSize);
- apiReturn = gGetTcpTable(buf, &dwSize, FALSE);
+ apiReturn = pGetTcpTable(buf, &dwSize, FALSE);
ok(apiReturn == NO_ERROR,
"GetTcpTable(buf, &dwSize, FALSE) returned %d, expected NO_ERROR\n",
apiReturn);
ntoa(buf->table[i].dwLocalAddr), ntohs(buf->table[i].dwLocalPort) );
trace( "%u: %s remote %s:%u state %u\n",
i, buffer, ntoa( buf->table[i].dwRemoteAddr ),
- ntohs(buf->table[i].dwRemotePort), buf->table[i].dwState );
+ ntohs(buf->table[i].dwRemotePort), U(buf->table[i]).dwState );
}
}
HeapFree(GetProcessHeap(), 0, buf);
static void testGetUdpTable(void)
{
- if (gGetUdpTable) {
+ if (pGetUdpTable) {
DWORD apiReturn;
ULONG dwSize = 0;
- apiReturn = gGetUdpTable(NULL, &dwSize, FALSE);
+ apiReturn = pGetUdpTable(NULL, &dwSize, FALSE);
if (apiReturn == ERROR_NOT_SUPPORTED) {
skip("GetUdpTable is not supported\n");
return;
if (apiReturn == ERROR_INSUFFICIENT_BUFFER) {
PMIB_UDPTABLE buf = HeapAlloc(GetProcessHeap(), 0, dwSize);
- apiReturn = gGetUdpTable(buf, &dwSize, FALSE);
+ apiReturn = pGetUdpTable(buf, &dwSize, FALSE);
ok(apiReturn == NO_ERROR,
"GetUdpTable(buf, &dwSize, FALSE) returned %d, expected NO_ERROR\n",
apiReturn);
}
}
+static void testSetTcpEntry(void)
+{
+ DWORD ret;
+ MIB_TCPROW row;
+
+ memset(&row, 0, sizeof(row));
+ if(0) /* This test crashes in OS >= VISTA */
+ {
+ ret = pSetTcpEntry(NULL);
+ ok( ret == ERROR_INVALID_PARAMETER, "got %u, expected %u\n", ret, ERROR_INVALID_PARAMETER);
+ }
+
+ ret = pSetTcpEntry(&row);
+ if (ret == ERROR_NETWORK_ACCESS_DENIED)
+ {
+ win_skip("SetTcpEntry failed with access error. Skipping test.\n");
+ return;
+ }
+ todo_wine ok( ret == ERROR_INVALID_PARAMETER, "got %u, expected %u\n", ret, ERROR_INVALID_PARAMETER);
+
+ U(row).dwState = MIB_TCP_STATE_DELETE_TCB;
+ ret = pSetTcpEntry(&row);
+ todo_wine ok( ret == ERROR_MR_MID_NOT_FOUND || broken(ret == ERROR_INVALID_PARAMETER),
+ "got %u, expected %u\n", ret, ERROR_MR_MID_NOT_FOUND);
+}
+
+static void testIcmpSendEcho(void)
+{
+ HANDLE icmp;
+ char senddata[32], replydata[sizeof(senddata) + sizeof(ICMP_ECHO_REPLY)];
+ DWORD ret, error, replysz = sizeof(replydata);
+ IPAddr address;
+
+ if (!pIcmpSendEcho || !pIcmpCreateFile)
+ {
+ win_skip( "IcmpSendEcho or IcmpCreateFile not available\n" );
+ return;
+ }
+ memset(senddata, 0, sizeof(senddata));
+
+ address = htonl(INADDR_LOOPBACK);
+ SetLastError(0xdeadbeef);
+ ret = pIcmpSendEcho(INVALID_HANDLE_VALUE, address, senddata, sizeof(senddata), NULL, replydata, replysz, 1000);
+ error = GetLastError();
+ ok (!ret, "IcmpSendEcho succeeded unexpectedly\n");
+todo_wine
+ ok (error == ERROR_INVALID_PARAMETER
+ || broken(error == ERROR_INVALID_HANDLE) /* <= 2003 */,
+ "expected 87, got %d\n", error);
+
+ icmp = pIcmpCreateFile();
+ if (icmp == INVALID_HANDLE_VALUE)
+ {
+ error = GetLastError();
+ if (error == ERROR_ACCESS_DENIED)
+ {
+ skip ("ICMP is not available.\n");
+ return;
+ }
+ }
+ ok (icmp != INVALID_HANDLE_VALUE, "IcmpCreateFile failed unexpectedly with error %d\n", GetLastError());
+
+ address = 0;
+ SetLastError(0xdeadbeef);
+ ret = pIcmpSendEcho(icmp, address, senddata, sizeof(senddata), NULL, replydata, replysz, 1000);
+ error = GetLastError();
+ ok (!ret, "IcmpSendEcho succeeded unexpectedly\n");
+ ok (error == ERROR_INVALID_NETNAME
+ || broken(error == IP_BAD_DESTINATION) /* <= 2003 */,
+ "expected 1214, got %d\n", error);
+
+ address = htonl(INADDR_LOOPBACK);
+ if (0) /* crashes in XP */
+ {
+ ret = pIcmpSendEcho(icmp, address, NULL, sizeof(senddata), NULL, replydata, replysz, 1000);
+ ok (!ret, "IcmpSendEcho succeeded unexpectedly\n");
+ }
+
+ SetLastError(0xdeadbeef);
+ ret = pIcmpSendEcho(icmp, address, senddata, 0, NULL, replydata, replysz, 1000);
+ error = GetLastError();
+ ok (ret, "IcmpSendEcho failed unexpectedly with error %d\n", error);
+
+ SetLastError(0xdeadbeef);
+ ret = pIcmpSendEcho(icmp, address, NULL, 0, NULL, replydata, replysz, 1000);
+ error = GetLastError();
+ ok (ret, "IcmpSendEcho failed unexpectedly with error %d\n", error);
+
+ if (0) /* crashes in wine, remove IF when fixed */
+ {
+ SetLastError(0xdeadbeef);
+ ret = pIcmpSendEcho(icmp, address, senddata, sizeof(senddata), NULL, NULL, replysz, 1000);
+ error = GetLastError();
+ ok (!ret, "IcmpSendEcho succeeded unexpectedly\n");
+ ok (error == ERROR_INVALID_PARAMETER, "expected 87, got %d\n", error);
+ }
+
+ SetLastError(0xdeadbeef);
+ ret = pIcmpSendEcho(icmp, address, senddata, sizeof(senddata), NULL, replydata, 0, 1000);
+ error = GetLastError();
+ ok (!ret, "IcmpSendEcho succeeded unexpectedly\n");
+todo_wine
+ ok (error == ERROR_INVALID_PARAMETER
+ || broken(error == ERROR_INSUFFICIENT_BUFFER) /* <= 2003 */,
+ "expected 87, got %d\n", error);
+
+ SetLastError(0xdeadbeef);
+ ret = pIcmpSendEcho(icmp, address, senddata, sizeof(senddata), NULL, NULL, 0, 1000);
+ error = GetLastError();
+ ok (!ret, "IcmpSendEcho succeeded unexpectedly\n");
+todo_wine
+ ok (error == ERROR_INVALID_PARAMETER
+ || broken(error == ERROR_INSUFFICIENT_BUFFER) /* <= 2003 */,
+ "expected 87, got %d\n", error);
+
+ SetLastError(0xdeadbeef);
+ replysz = sizeof(replydata) - 1;
+ ret = pIcmpSendEcho(icmp, address, senddata, sizeof(senddata), NULL, replydata, replysz, 1000);
+ error = GetLastError();
+ todo_wine {
+ ok (!ret, "IcmpSendEcho succeeded unexpectedly\n");
+ ok (error == IP_GENERAL_FAILURE
+ || broken(error == IP_BUF_TOO_SMALL) /* <= 2003 */,
+ "expected 11050, got %d\n", error);
+ }
+
+ SetLastError(0xdeadbeef);
+ replysz = sizeof(ICMP_ECHO_REPLY);
+ ret = pIcmpSendEcho(icmp, address, senddata, 0, NULL, replydata, replysz, 1000);
+ error = GetLastError();
+todo_wine
+ ok (ret, "IcmpSendEcho failed unexpectedly with error %d\n", error);
+
+ SetLastError(0xdeadbeef);
+ replysz = sizeof(ICMP_ECHO_REPLY) + ICMP_MINLEN;
+ ret = pIcmpSendEcho(icmp, address, senddata, ICMP_MINLEN, NULL, replydata, replysz, 1000);
+ error = GetLastError();
+todo_wine
+ ok (ret, "IcmpSendEcho failed unexpectedly with error %d\n", error);
+
+ SetLastError(0xdeadbeef);
+ replysz = sizeof(ICMP_ECHO_REPLY) + ICMP_MINLEN;
+ ret = pIcmpSendEcho(icmp, address, senddata, ICMP_MINLEN + 1, NULL, replydata, replysz, 1000);
+ error = GetLastError();
+ ok (!ret, "IcmpSendEcho succeeded unexpectedly\n");
+todo_wine
+ ok (error == IP_GENERAL_FAILURE
+ || broken(error == IP_BUF_TOO_SMALL) /* <= 2003 */,
+ "expected 11050, got %d\n", error);
+
+ SetLastError(0xdeadbeef);
+ ret = pIcmpSendEcho(icmp, address, senddata, ICMP_MINLEN, NULL, replydata, replysz - 1, 1000);
+ error = GetLastError();
+ ok (!ret, "IcmpSendEcho succeeded unexpectedly\n");
+todo_wine
+ ok (error == IP_GENERAL_FAILURE
+ || broken(error == IP_BUF_TOO_SMALL) /* <= 2003 */,
+ "expected 11050, got %d\n", error);
+
+ /* in windows >= vista the timeout can't be invalid */
+ SetLastError(0xdeadbeef);
+ replysz = sizeof(replydata);
+ ret = pIcmpSendEcho(icmp, address, senddata, sizeof(senddata), NULL, replydata, replysz, 0);
+ error = GetLastError();
+ if (!ret) ok(error == ERROR_INVALID_PARAMETER, "expected 87, got %d\n", error);
+
+ SetLastError(0xdeadbeef);
+ ret = pIcmpSendEcho(icmp, address, senddata, sizeof(senddata), NULL, replydata, replysz, -1);
+ error = GetLastError();
+ if (!ret) ok(error == ERROR_INVALID_PARAMETER, "expected 87, got %d\n", error);
+
+ /* real ping test */
+ SetLastError(0xdeadbeef);
+ address = htonl(INADDR_LOOPBACK);
+ ret = pIcmpSendEcho(icmp, address, senddata, sizeof(senddata), NULL, replydata, replysz, 1000);
+ error = GetLastError();
+ if (ret)
+ {
+ PICMP_ECHO_REPLY pong = (PICMP_ECHO_REPLY) replydata;
+ trace ("send addr : %s\n", ntoa(address));
+ trace ("reply addr : %s\n", ntoa(pong->Address));
+ trace ("reply size : %u\n", replysz);
+ trace ("roundtrip : %u ms\n", pong->RoundTripTime);
+ trace ("status : %u\n", pong->Status);
+ trace ("recv size : %u\n", pong->DataSize);
+ trace ("ttl : %u\n", pong->Options.Ttl);
+ trace ("flags : 0x%x\n", pong->Options.Flags);
+ }
+ else
+ {
+ skip ("Failed to ping with error %d, is lo interface down?.\n", error);
+ }
+}
+
/*
still-to-be-tested NT4-onward functions:
CreateIpForwardEntry
SetIpNetEntry
SetIpStatistics
SetIpTTL
-SetTcpEntry
*/
static void testWinNT4Functions(void)
{
testGetIpStatistics();
testGetTcpStatistics();
testGetUdpStatistics();
+ testGetIcmpStatisticsEx();
+ testGetIpStatisticsEx();
+ testGetTcpStatisticsEx();
+ testGetUdpStatisticsEx();
testGetTcpTable();
testGetUdpTable();
+ testSetTcpEntry();
+ testIcmpSendEcho();
}
static void testGetInterfaceInfo(void)
{
- if (gGetInterfaceInfo) {
+ if (pGetInterfaceInfo) {
DWORD apiReturn;
ULONG len = 0;
- apiReturn = gGetInterfaceInfo(NULL, NULL);
+ apiReturn = pGetInterfaceInfo(NULL, NULL);
if (apiReturn == ERROR_NOT_SUPPORTED) {
skip("GetInterfaceInfo is not supported\n");
return;
ok(apiReturn == ERROR_INVALID_PARAMETER,
"GetInterfaceInfo returned %d, expected ERROR_INVALID_PARAMETER\n",
apiReturn);
- apiReturn = gGetInterfaceInfo(NULL, &len);
+ apiReturn = pGetInterfaceInfo(NULL, &len);
ok(apiReturn == ERROR_INSUFFICIENT_BUFFER,
"GetInterfaceInfo returned %d, expected ERROR_INSUFFICIENT_BUFFER\n",
apiReturn);
if (apiReturn == ERROR_INSUFFICIENT_BUFFER) {
PIP_INTERFACE_INFO buf = HeapAlloc(GetProcessHeap(), 0, len);
- apiReturn = gGetInterfaceInfo(buf, &len);
+ apiReturn = pGetInterfaceInfo(buf, &len);
ok(apiReturn == NO_ERROR,
"GetInterfaceInfo(buf, &dwSize) returned %d, expected NO_ERROR\n",
apiReturn);
static void testGetAdaptersInfo(void)
{
- if (gGetAdaptersInfo) {
+ if (pGetAdaptersInfo) {
DWORD apiReturn;
ULONG len = 0;
- apiReturn = gGetAdaptersInfo(NULL, NULL);
+ apiReturn = pGetAdaptersInfo(NULL, NULL);
if (apiReturn == ERROR_NOT_SUPPORTED) {
skip("GetAdaptersInfo is not supported\n");
return;
ok(apiReturn == ERROR_INVALID_PARAMETER,
"GetAdaptersInfo returned %d, expected ERROR_INVALID_PARAMETER\n",
apiReturn);
- apiReturn = gGetAdaptersInfo(NULL, &len);
+ apiReturn = pGetAdaptersInfo(NULL, &len);
ok(apiReturn == ERROR_NO_DATA || apiReturn == ERROR_BUFFER_OVERFLOW,
"GetAdaptersInfo returned %d, expected ERROR_NO_DATA or ERROR_BUFFER_OVERFLOW\n",
apiReturn);
if (apiReturn == ERROR_NO_DATA)
; /* no adapter's, that's okay */
else if (apiReturn == ERROR_BUFFER_OVERFLOW) {
- PIP_ADAPTER_INFO buf = HeapAlloc(GetProcessHeap(), 0, len);
+ PIP_ADAPTER_INFO ptr, buf = HeapAlloc(GetProcessHeap(), 0, len);
- apiReturn = gGetAdaptersInfo(buf, &len);
+ apiReturn = pGetAdaptersInfo(buf, &len);
ok(apiReturn == NO_ERROR,
"GetAdaptersInfo(buf, &dwSize) returned %d, expected NO_ERROR\n",
apiReturn);
+ ptr = buf;
+ while (ptr) {
+ ok(ptr->IpAddressList.IpAddress.String[0], "A valid IP must be present\n");
+ ok(ptr->IpAddressList.IpMask.String[0], "A valid mask must be present\n");
+ trace("Adapter '%s', IP %s, Mask %s\n", ptr->AdapterName,
+ ptr->IpAddressList.IpAddress.String, ptr->IpAddressList.IpMask.String);
+ ptr = ptr->Next;
+ }
HeapFree(GetProcessHeap(), 0, buf);
}
}
static void testGetNetworkParams(void)
{
- if (gGetNetworkParams) {
+ if (pGetNetworkParams) {
DWORD apiReturn;
ULONG len = 0;
- apiReturn = gGetNetworkParams(NULL, NULL);
+ apiReturn = pGetNetworkParams(NULL, NULL);
if (apiReturn == ERROR_NOT_SUPPORTED) {
skip("GetNetworkParams is not supported\n");
return;
ok(apiReturn == ERROR_INVALID_PARAMETER,
"GetNetworkParams returned %d, expected ERROR_INVALID_PARAMETER\n",
apiReturn);
- apiReturn = gGetNetworkParams(NULL, &len);
+ apiReturn = pGetNetworkParams(NULL, &len);
ok(apiReturn == ERROR_BUFFER_OVERFLOW,
"GetNetworkParams returned %d, expected ERROR_BUFFER_OVERFLOW\n",
apiReturn);
if (apiReturn == ERROR_BUFFER_OVERFLOW) {
PFIXED_INFO buf = HeapAlloc(GetProcessHeap(), 0, len);
- apiReturn = gGetNetworkParams(buf, &len);
+ apiReturn = pGetNetworkParams(buf, &len);
ok(apiReturn == NO_ERROR,
"GetNetworkParams(buf, &dwSize) returned %d, expected NO_ERROR\n",
apiReturn);
DWORD ret, needed;
void *buffer;
- if (!gGetPerAdapterInfo) return;
- ret = gGetPerAdapterInfo(1, NULL, NULL);
+ if (!pGetPerAdapterInfo) return;
+ ret = pGetPerAdapterInfo(1, NULL, NULL);
if (ret == ERROR_NOT_SUPPORTED) {
skip("GetPerAdapterInfo is not supported\n");
return;
}
ok( ret == ERROR_INVALID_PARAMETER, "got %u instead of ERROR_INVALID_PARAMETER\n", ret );
needed = 0xdeadbeef;
- ret = gGetPerAdapterInfo(1, NULL, &needed);
+ ret = pGetPerAdapterInfo(1, NULL, &needed);
if (ret == ERROR_NO_DATA) return; /* no such adapter */
ok( ret == ERROR_BUFFER_OVERFLOW, "got %u instead of ERROR_BUFFER_OVERFLOW\n", ret );
ok( needed != 0xdeadbeef, "needed not set\n" );
buffer = HeapAlloc( GetProcessHeap(), 0, needed );
- ret = gGetPerAdapterInfo(1, buffer, &needed);
+ ret = pGetPerAdapterInfo(1, buffer, &needed);
ok( ret == NO_ERROR, "got %u instead of NO_ERROR\n", ret );
HeapFree( GetProcessHeap(), 0, buffer );
}
HANDLE handle;
BOOL success;
- if (!gNotifyAddrChange)
+ if (!pNotifyAddrChange)
{
win_skip("NotifyAddrChange not present\n");
return;
}
- if (!gCancelIPChangeNotify)
+ if (!pCancelIPChangeNotify)
{
win_skip("CancelIPChangeNotify not present\n");
return;
handle = NULL;
ZeroMemory(&overlapped, sizeof(overlapped));
- ret = gNotifyAddrChange(&handle, &overlapped);
+ ret = pNotifyAddrChange(&handle, &overlapped);
if (ret == ERROR_NOT_SUPPORTED)
{
win_skip("NotifyAddrChange is not supported\n");
ok(ret == ERROR_IO_PENDING, "NotifyAddrChange returned %d, expected ERROR_IO_PENDING\n", ret);
ret = GetLastError();
todo_wine ok(ret == ERROR_IO_PENDING, "GetLastError returned %d, expected ERROR_IO_PENDING\n", ret);
- success = gCancelIPChangeNotify(&overlapped);
+ success = pCancelIPChangeNotify(&overlapped);
todo_wine ok(success == TRUE, "CancelIPChangeNotify returned FALSE, expected TRUE\n");
ZeroMemory(&overlapped, sizeof(overlapped));
- success = gCancelIPChangeNotify(&overlapped);
+ success = pCancelIPChangeNotify(&overlapped);
ok(success == FALSE, "CancelIPChangeNotify returned TRUE, expected FALSE\n");
handle = NULL;
ZeroMemory(&overlapped, sizeof(overlapped));
- overlapped.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
- ret = gNotifyAddrChange(&handle, &overlapped);
+ overlapped.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
+ ret = pNotifyAddrChange(&handle, &overlapped);
ok(ret == ERROR_IO_PENDING, "NotifyAddrChange returned %d, expected ERROR_IO_PENDING\n", ret);
todo_wine ok(handle != INVALID_HANDLE_VALUE, "NotifyAddrChange returned invalid file handle\n");
success = GetOverlappedResult(handle, &overlapped, &bytes, FALSE);
ok(success == FALSE, "GetOverlappedResult returned TRUE, expected FALSE\n");
ret = GetLastError();
ok(ret == ERROR_IO_INCOMPLETE, "GetLastError returned %d, expected ERROR_IO_INCOMPLETE\n", ret);
- success = gCancelIPChangeNotify(&overlapped);
+ success = pCancelIPChangeNotify(&overlapped);
todo_wine ok(success == TRUE, "CancelIPChangeNotify returned FALSE, expected TRUE\n");
if (winetest_interactive)
{
handle = NULL;
ZeroMemory(&overlapped, sizeof(overlapped));
- overlapped.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+ overlapped.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
trace("Testing asynchronous ipv4 address change notification. Please "
"change the ipv4 address of one of your network interfaces\n");
- ret = gNotifyAddrChange(&handle, &overlapped);
+ ret = pNotifyAddrChange(&handle, &overlapped);
ok(ret == ERROR_IO_PENDING, "NotifyAddrChange returned %d, expected NO_ERROR\n", ret);
success = GetOverlappedResult(handle, &overlapped, &bytes, TRUE);
ok(success == TRUE, "GetOverlappedResult returned FALSE, expected TRUE\n");
{
trace("Testing synchronous ipv4 address change notification. Please "
"change the ipv4 address of one of your network interfaces\n");
- ret = gNotifyAddrChange(NULL, NULL);
+ ret = pNotifyAddrChange(NULL, NULL);
todo_wine ok(ret == NO_ERROR, "NotifyAddrChange returned %d, expected NO_ERROR\n", ret);
}
}
static void test_GetAdaptersAddresses(void)
{
- ULONG ret, size;
+ ULONG ret, size, osize, i;
IP_ADAPTER_ADDRESSES *aa, *ptr;
IP_ADAPTER_UNICAST_ADDRESS *ua;
- if (!gGetAdaptersAddresses)
+ if (!pGetAdaptersAddresses)
{
win_skip("GetAdaptersAddresses not present\n");
return;
}
- ret = gGetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, NULL);
+ ret = pGetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, NULL);
ok(ret == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER got %u\n", ret);
/* size should be ignored and overwritten if buffer is NULL */
size = 0x7fffffff;
- ret = gGetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &size);
+ ret = pGetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &size);
ok(ret == ERROR_BUFFER_OVERFLOW, "expected ERROR_BUFFER_OVERFLOW, got %u\n", ret);
if (ret != ERROR_BUFFER_OVERFLOW) return;
ptr = HeapAlloc(GetProcessHeap(), 0, size);
- ret = gGetAdaptersAddresses(AF_UNSPEC, 0, NULL, ptr, &size);
+ ret = pGetAdaptersAddresses(AF_UNSPEC, 0, NULL, ptr, &size);
+ ok(!ret, "expected ERROR_SUCCESS got %u\n", ret);
+ HeapFree(GetProcessHeap(), 0, ptr);
+
+ /* higher size must not be changed to lower size */
+ size *= 2;
+ osize = size;
+ ptr = HeapAlloc(GetProcessHeap(), 0, osize);
+ ret = pGetAdaptersAddresses(AF_UNSPEC, 0, NULL, ptr, &osize);
ok(!ret, "expected ERROR_SUCCESS got %u\n", ret);
+ ok(osize == size, "expected %d, got %d\n", size, osize);
for (aa = ptr; !ret && aa; aa = aa->Next)
{
+ char temp[128];
+
+ ok(S(U(*aa)).Length == sizeof(IP_ADAPTER_ADDRESSES_LH) ||
+ S(U(*aa)).Length == sizeof(IP_ADAPTER_ADDRESSES_XP),
+ "Unknown structure size of %u bytes\n", S(U(*aa)).Length);
ok(aa->DnsSuffix != NULL, "DnsSuffix is not a valid pointer\n");
ok(aa->Description != NULL, "Description is not a valid pointer\n");
ok(aa->FriendlyName != NULL, "FriendlyName is not a valid pointer\n");
- if (winetest_debug <= 1)
- continue;
-
+ trace("\n");
trace("Length: %u\n", S(U(*aa)).Length);
trace("IfIndex: %u\n", S(U(*aa)).IfIndex);
trace("Next: %p\n", aa->Next);
ua = aa->FirstUnicastAddress;
while (ua)
{
+ ok(ua->PrefixOrigin != IpPrefixOriginOther,
+ "bad address config value %d\n", ua->PrefixOrigin);
+ ok(ua->SuffixOrigin != IpSuffixOriginOther,
+ "bad address config value %d\n", ua->PrefixOrigin);
+ /* Address configured manually or from DHCP server? */
+ if (ua->PrefixOrigin == IpPrefixOriginManual ||
+ ua->PrefixOrigin == IpPrefixOriginDhcp)
+ {
+ ok(ua->ValidLifetime, "expected non-zero value\n");
+ ok(ua->PreferredLifetime, "expected non-zero value\n");
+ ok(ua->LeaseLifetime, "expected non-zero\n");
+ }
+ /* Is the address ok in the network (not duplicated)? */
+ ok(ua->DadState != IpDadStateInvalid && ua->DadState != IpDadStateDuplicate,
+ "bad address duplication value %d\n", ua->DadState);
trace("\tLength: %u\n", S(U(*ua)).Length);
trace("\tFlags: 0x%08x\n", S(U(*ua)).Flags);
trace("\tNext: %p\n", ua->Next);
trace("\tPrefixOrigin: %u\n", ua->PrefixOrigin);
trace("\tSuffixOrigin: %u\n", ua->SuffixOrigin);
trace("\tDadState: %u\n", ua->DadState);
- trace("\tValidLifetime: 0x%08x\n", ua->ValidLifetime);
- trace("\tPreferredLifetime: 0x%08x\n", ua->PreferredLifetime);
- trace("\tLeaseLifetime: 0x%08x\n", ua->LeaseLifetime);
+ trace("\tValidLifetime: %u seconds\n", ua->ValidLifetime);
+ trace("\tPreferredLifetime: %u seconds\n", ua->PreferredLifetime);
+ trace("\tLeaseLifetime: %u seconds\n", ua->LeaseLifetime);
trace("\n");
ua = ua->Next;
}
trace("FirstAnycastAddress: %p\n", aa->FirstAnycastAddress);
trace("FirstMulticastAddress: %p\n", aa->FirstMulticastAddress);
trace("FirstDnsServerAddress: %p\n", aa->FirstDnsServerAddress);
- trace("DnsSuffix: %p\n", aa->DnsSuffix);
- trace("Description: %p\n", aa->Description);
- trace("FriendlyName: %p\n", aa->FriendlyName);
- trace("PhysicalAddress: %02x\n", aa->PhysicalAddress[0]);
+ trace("DnsSuffix: %s %p\n", wine_dbgstr_w(aa->DnsSuffix), aa->DnsSuffix);
+ trace("Description: %s %p\n", wine_dbgstr_w(aa->Description), aa->Description);
+ trace("FriendlyName: %s %p\n", wine_dbgstr_w(aa->FriendlyName), aa->FriendlyName);
trace("PhysicalAddressLength: %u\n", aa->PhysicalAddressLength);
+ for (i = 0; i < aa->PhysicalAddressLength; i++)
+ sprintf(temp + i * 3, "%02X-", aa->PhysicalAddress[i]);
+ temp[i ? i * 3 - 1 : 0] = '\0';
+ trace("PhysicalAddress: %s\n", temp);
trace("Flags: 0x%08x\n", aa->Flags);
trace("Mtu: %u\n", aa->Mtu);
trace("IfType: %u\n", aa->IfType);
trace("OperStatus: %u\n", aa->OperStatus);
+ trace("Ipv6IfIndex: %u\n", aa->Ipv6IfIndex);
+ for (i = 0, temp[0] = '\0'; i < sizeof(aa->ZoneIndices) / sizeof(aa->ZoneIndices[0]); i++)
+ sprintf(temp + strlen(temp), "%d ", aa->ZoneIndices[i]);
+ trace("ZoneIndices: %s\n", temp);
+ trace("FirstPrefix: %p\n", aa->FirstPrefix);
+
+ if (S(U(*aa)).Length < sizeof(IP_ADAPTER_ADDRESSES_LH)) continue;
+#ifndef __REACTOS__
+ trace("TransmitLinkSpeed: %s\n", debugstr_longlong(aa->TransmitLinkSpeed));
+ trace("ReceiveLinkSpeed: %s\n", debugstr_longlong(aa->ReceiveLinkSpeed));
+ trace("FirstWinsServerAddress:%p\n", aa->FirstWinsServerAddress);
+ trace("FirstGatewayAddress: %p\n", aa->FirstGatewayAddress);
+ trace("Ipv4Metric: %u\n", aa->Ipv4Metric);
+ trace("Ipv6Metric: %u\n", aa->Ipv6Metric);
+ trace("Luid: %p\n", &aa->Luid);
+ trace("Dhcpv4Server: %p\n", &aa->Dhcpv4Server);
+ trace("CompartmentId: %u\n", aa->CompartmentId);
+ trace("NetworkGuid: %s\n", wine_dbgstr_guid((GUID*) &aa->NetworkGuid));
+ trace("ConnectionType: %u\n", aa->ConnectionType);
+ trace("TunnelType: %u\n", aa->TunnelType);
+ trace("Dhcpv6Server: %p\n", &aa->Dhcpv6Server);
+ trace("Dhcpv6ClientDuidLength:%u\n", aa->Dhcpv6ClientDuidLength);
+ trace("Dhcpv6ClientDuid: %p\n", aa->Dhcpv6ClientDuid);
+ trace("Dhcpv6Iaid: %u\n", aa->Dhcpv6Iaid);
+ trace("FirstDnsSuffix: %p\n", aa->FirstDnsSuffix);
trace("\n");
+#endif
}
HeapFree(GetProcessHeap(), 0, ptr);
}
+static void test_GetExtendedTcpTable(void)
+{
+ DWORD ret, size;
+ MIB_TCPTABLE *table;
+ MIB_TCPTABLE_OWNER_PID *table_pid;
+ MIB_TCPTABLE_OWNER_MODULE *table_module;
+
+ if (!pGetExtendedTcpTable)
+ {
+ win_skip("GetExtendedTcpTable not available\n");
+ return;
+ }
+ ret = pGetExtendedTcpTable( NULL, NULL, TRUE, AF_INET, TCP_TABLE_BASIC_ALL, 0 );
+ ok( ret == ERROR_INVALID_PARAMETER, "got %u\n", ret );
+
+ size = 0;
+ ret = pGetExtendedTcpTable( NULL, &size, TRUE, AF_INET, TCP_TABLE_BASIC_ALL, 0 );
+ ok( ret == ERROR_INSUFFICIENT_BUFFER, "got %u\n", ret );
+
+ table = HeapAlloc( GetProcessHeap(), 0, size );
+ ret = pGetExtendedTcpTable( table, &size, TRUE, AF_INET, TCP_TABLE_BASIC_ALL, 0 );
+ ok( ret == ERROR_SUCCESS, "got %u\n", ret );
+ HeapFree( GetProcessHeap(), 0, table );
+
+ size = 0;
+ ret = pGetExtendedTcpTable( NULL, &size, TRUE, AF_INET, TCP_TABLE_BASIC_LISTENER, 0 );
+ ok( ret == ERROR_INSUFFICIENT_BUFFER, "got %u\n", ret );
+
+ table = HeapAlloc( GetProcessHeap(), 0, size );
+ ret = pGetExtendedTcpTable( table, &size, TRUE, AF_INET, TCP_TABLE_BASIC_LISTENER, 0 );
+ ok( ret == ERROR_SUCCESS, "got %u\n", ret );
+ HeapFree( GetProcessHeap(), 0, table );
+
+ size = 0;
+ ret = pGetExtendedTcpTable( NULL, &size, TRUE, AF_INET, TCP_TABLE_OWNER_PID_ALL, 0 );
+ ok( ret == ERROR_INSUFFICIENT_BUFFER, "got %u\n", ret );
+
+ table_pid = HeapAlloc( GetProcessHeap(), 0, size );
+ ret = pGetExtendedTcpTable( table_pid, &size, TRUE, AF_INET, TCP_TABLE_OWNER_PID_ALL, 0 );
+ ok( ret == ERROR_SUCCESS, "got %u\n", ret );
+ HeapFree( GetProcessHeap(), 0, table_pid );
+
+ size = 0;
+ ret = pGetExtendedTcpTable( NULL, &size, TRUE, AF_INET, TCP_TABLE_OWNER_PID_LISTENER, 0 );
+ ok( ret == ERROR_INSUFFICIENT_BUFFER, "got %u\n", ret );
+
+ table_pid = HeapAlloc( GetProcessHeap(), 0, size );
+ ret = pGetExtendedTcpTable( table_pid, &size, TRUE, AF_INET, TCP_TABLE_OWNER_PID_LISTENER, 0 );
+ ok( ret == ERROR_SUCCESS, "got %u\n", ret );
+ HeapFree( GetProcessHeap(), 0, table_pid );
+
+ size = 0;
+ ret = pGetExtendedTcpTable( NULL, &size, TRUE, AF_INET, TCP_TABLE_OWNER_MODULE_ALL, 0 );
+ ok( ret == ERROR_INSUFFICIENT_BUFFER, "got %u\n", ret );
+
+ table_module = HeapAlloc( GetProcessHeap(), 0, size );
+ ret = pGetExtendedTcpTable( table_module, &size, TRUE, AF_INET, TCP_TABLE_OWNER_MODULE_ALL, 0 );
+ ok( ret == ERROR_SUCCESS, "got %u\n", ret );
+ HeapFree( GetProcessHeap(), 0, table_module );
+
+ size = 0;
+ ret = pGetExtendedTcpTable( NULL, &size, TRUE, AF_INET, TCP_TABLE_OWNER_MODULE_LISTENER, 0 );
+ ok( ret == ERROR_INSUFFICIENT_BUFFER, "got %u\n", ret );
+
+ table_module = HeapAlloc( GetProcessHeap(), 0, size );
+ ret = pGetExtendedTcpTable( table_module, &size, TRUE, AF_INET, TCP_TABLE_OWNER_MODULE_LISTENER, 0 );
+ ok( ret == ERROR_SUCCESS, "got %u\n", ret );
+ HeapFree( GetProcessHeap(), 0, table_module );
+}
+
+static void test_GetExtendedUdpTable(void)
+{
+ DWORD ret, size;
+ MIB_UDPTABLE *table;
+ MIB_UDPTABLE_OWNER_PID *table_pid;
+ MIB_UDPTABLE_OWNER_MODULE *table_module;
+
+ if (!pGetExtendedUdpTable)
+ {
+ win_skip("GetExtendedUdpTable not available\n");
+ return;
+ }
+ ret = pGetExtendedUdpTable( NULL, NULL, TRUE, AF_INET, UDP_TABLE_BASIC, 0 );
+ ok( ret == ERROR_INVALID_PARAMETER, "got %u\n", ret );
+
+ size = 0;
+ ret = pGetExtendedUdpTable( NULL, &size, TRUE, AF_INET, UDP_TABLE_BASIC, 0 );
+ ok( ret == ERROR_INSUFFICIENT_BUFFER, "got %u\n", ret );
+
+ table = HeapAlloc( GetProcessHeap(), 0, size );
+ ret = pGetExtendedUdpTable( table, &size, TRUE, AF_INET, UDP_TABLE_BASIC, 0 );
+ ok( ret == ERROR_SUCCESS, "got %u\n", ret );
+ HeapFree( GetProcessHeap(), 0, table );
+
+ size = 0;
+ ret = pGetExtendedUdpTable( NULL, &size, TRUE, AF_INET, UDP_TABLE_OWNER_PID, 0 );
+ ok( ret == ERROR_INSUFFICIENT_BUFFER, "got %u\n", ret );
+
+ table_pid = HeapAlloc( GetProcessHeap(), 0, size );
+ ret = pGetExtendedUdpTable( table_pid, &size, TRUE, AF_INET, UDP_TABLE_OWNER_PID, 0 );
+ ok( ret == ERROR_SUCCESS, "got %u\n", ret );
+ HeapFree( GetProcessHeap(), 0, table_pid );
+
+ size = 0;
+ ret = pGetExtendedUdpTable( NULL, &size, TRUE, AF_INET, UDP_TABLE_OWNER_MODULE, 0 );
+ ok( ret == ERROR_INSUFFICIENT_BUFFER, "got %u\n", ret );
+
+ table_module = HeapAlloc( GetProcessHeap(), 0, size );
+ ret = pGetExtendedUdpTable( table_module, &size, TRUE, AF_INET, UDP_TABLE_OWNER_MODULE, 0 );
+ ok( ret == ERROR_SUCCESS, "got %u\n", ret );
+ HeapFree( GetProcessHeap(), 0, table_module );
+}
+
+static void test_CreateSortedAddressPairs(void)
+{
+ SOCKADDR_IN6 dst[2];
+ SOCKADDR_IN6_PAIR *pair;
+ ULONG pair_count;
+ DWORD ret;
+
+ if (!pCreateSortedAddressPairs)
+ {
+ win_skip( "CreateSortedAddressPairs not available\n" );
+ return;
+ }
+
+ memset( dst, 0, sizeof(dst) );
+ dst[0].sin6_family = AF_INET6;
+ dst[0].sin6_addr.u.Word[5] = 0xffff;
+ dst[0].sin6_addr.u.Word[6] = 0x0808;
+ dst[0].sin6_addr.u.Word[7] = 0x0808;
+
+ pair_count = 0xdeadbeef;
+ ret = pCreateSortedAddressPairs( NULL, 0, dst, 1, 0, NULL, &pair_count );
+ ok( ret == ERROR_INVALID_PARAMETER, "got %u\n", ret );
+ ok( pair_count == 0xdeadbeef, "got %u\n", pair_count );
+
+ pair = (SOCKADDR_IN6_PAIR *)0xdeadbeef;
+ pair_count = 0xdeadbeef;
+ ret = pCreateSortedAddressPairs( NULL, 0, NULL, 1, 0, &pair, &pair_count );
+ ok( ret == ERROR_INVALID_PARAMETER, "got %u\n", ret );
+ ok( pair == (SOCKADDR_IN6_PAIR *)0xdeadbeef, "got %p\n", pair );
+ ok( pair_count == 0xdeadbeef, "got %u\n", pair_count );
+
+ pair = NULL;
+ pair_count = 0xdeadbeef;
+ ret = pCreateSortedAddressPairs( NULL, 0, dst, 1, 0, &pair, &pair_count );
+ ok( ret == NO_ERROR, "got %u\n", ret );
+ ok( pair != NULL, "pair not set\n" );
+ ok( pair_count >= 1, "got %u\n", pair_count );
+ ok( pair[0].SourceAddress != NULL, "src address not set\n" );
+ ok( pair[0].DestinationAddress != NULL, "dst address not set\n" );
+ pFreeMibTable( pair );
+
+ dst[1].sin6_family = AF_INET6;
+ dst[1].sin6_addr.u.Word[5] = 0xffff;
+ dst[1].sin6_addr.u.Word[6] = 0x0404;
+ dst[1].sin6_addr.u.Word[7] = 0x0808;
+
+ pair = NULL;
+ pair_count = 0xdeadbeef;
+ ret = pCreateSortedAddressPairs( NULL, 0, dst, 2, 0, &pair, &pair_count );
+ ok( ret == NO_ERROR, "got %u\n", ret );
+ ok( pair != NULL, "pair not set\n" );
+ ok( pair_count >= 2, "got %u\n", pair_count );
+ ok( pair[0].SourceAddress != NULL, "src address not set\n" );
+ ok( pair[0].DestinationAddress != NULL, "dst address not set\n" );
+ ok( pair[1].SourceAddress != NULL, "src address not set\n" );
+ ok( pair[1].DestinationAddress != NULL, "dst address not set\n" );
+ pFreeMibTable( pair );
+}
+
+static DWORD get_interface_index(void)
+{
+ DWORD size = 0, ret = 0;
+ IP_ADAPTER_ADDRESSES *buf, *aa;
+
+ if (pGetAdaptersAddresses( AF_UNSPEC, 0, NULL, NULL, &size ) != ERROR_BUFFER_OVERFLOW)
+ return 0;
+
+ buf = HeapAlloc( GetProcessHeap(), 0, size );
+ pGetAdaptersAddresses( AF_UNSPEC, 0, NULL, buf, &size );
+ for (aa = buf; aa; aa = aa->Next)
+ {
+ if (aa->IfType == IF_TYPE_ETHERNET_CSMACD)
+ {
+ ret = aa->IfIndex;
+ break;
+ }
+ }
+ HeapFree( GetProcessHeap(), 0, buf );
+ return ret;
+}
+
+static void test_interface_identifier_conversion(void)
+{
+ DWORD ret;
+ NET_LUID luid;
+ GUID guid;
+ SIZE_T len;
+ WCHAR nameW[IF_MAX_STRING_SIZE + 1];
+ char nameA[IF_MAX_STRING_SIZE + 1];
+ NET_IFINDEX index;
+
+ if (!pConvertInterfaceIndexToLuid)
+ {
+ win_skip( "ConvertInterfaceIndexToLuid not available\n" );
+ return;
+ }
+ if (!(index = get_interface_index()))
+ {
+ skip( "no suitable interface found\n" );
+ return;
+ }
+
+ /* ConvertInterfaceIndexToLuid */
+ ret = pConvertInterfaceIndexToLuid( 0, NULL );
+ ok( ret == ERROR_INVALID_PARAMETER, "got %u\n", ret );
+
+ memset( &luid, 0xff, sizeof(luid) );
+ ret = pConvertInterfaceIndexToLuid( 0, &luid );
+ ok( ret == ERROR_FILE_NOT_FOUND, "got %u\n", ret );
+ ok( !luid.Info.Reserved, "got %x\n", luid.Info.Reserved );
+ ok( !luid.Info.NetLuidIndex, "got %u\n", luid.Info.NetLuidIndex );
+ ok( !luid.Info.IfType, "got %u\n", luid.Info.IfType );
+
+ luid.Info.Reserved = luid.Info.NetLuidIndex = luid.Info.IfType = 0xdead;
+ ret = pConvertInterfaceIndexToLuid( index, &luid );
+ ok( !ret, "got %u\n", ret );
+ ok( !luid.Info.Reserved, "got %x\n", luid.Info.Reserved );
+ ok( luid.Info.NetLuidIndex != 0xdead, "index not set\n" );
+ ok( luid.Info.IfType == IF_TYPE_ETHERNET_CSMACD, "got %u\n", luid.Info.IfType );
+
+ /* ConvertInterfaceLuidToIndex */
+ ret = pConvertInterfaceLuidToIndex( NULL, NULL );
+ ok( ret == ERROR_INVALID_PARAMETER, "got %u\n", ret );
+
+ ret = pConvertInterfaceLuidToIndex( NULL, &index );
+ ok( ret == ERROR_INVALID_PARAMETER, "got %u\n", ret );
+
+ ret = pConvertInterfaceLuidToIndex( &luid, NULL );
+ ok( ret == ERROR_INVALID_PARAMETER, "got %u\n", ret );
+
+ ret = pConvertInterfaceLuidToIndex( &luid, &index );
+ ok( !ret, "got %u\n", ret );
+
+ /* ConvertInterfaceLuidToGuid */
+ ret = pConvertInterfaceLuidToGuid( NULL, NULL );
+ ok( ret == ERROR_INVALID_PARAMETER, "got %u\n", ret );
+
+ memset( &guid, 0xff, sizeof(guid) );
+ ret = pConvertInterfaceLuidToGuid( NULL, &guid );
+ ok( ret == ERROR_INVALID_PARAMETER, "got %u\n", ret );
+ ok( guid.Data1 == 0xffffffff, "got %x\n", guid.Data1 );
+
+ ret = pConvertInterfaceLuidToGuid( &luid, NULL );
+ ok( ret == ERROR_INVALID_PARAMETER, "got %u\n", ret );
+
+ memset( &guid, 0, sizeof(guid) );
+ ret = pConvertInterfaceLuidToGuid( &luid, &guid );
+ ok( !ret, "got %u\n", ret );
+ ok( guid.Data1, "got %x\n", guid.Data1 );
+
+ /* ConvertInterfaceGuidToLuid */
+ ret = pConvertInterfaceGuidToLuid( NULL, NULL );
+ ok( ret == ERROR_INVALID_PARAMETER, "got %u\n", ret );
+
+ luid.Info.NetLuidIndex = 1;
+ ret = pConvertInterfaceGuidToLuid( NULL, &luid );
+ ok( ret == ERROR_INVALID_PARAMETER, "got %u\n", ret );
+ ok( luid.Info.NetLuidIndex == 1, "got %u\n", luid.Info.NetLuidIndex );
+
+ ret = pConvertInterfaceGuidToLuid( &guid, NULL );
+ ok( ret == ERROR_INVALID_PARAMETER, "got %u\n", ret );
+
+ luid.Info.Reserved = luid.Info.NetLuidIndex = luid.Info.IfType = 0xdead;
+ ret = pConvertInterfaceGuidToLuid( &guid, &luid );
+ ok( !ret, "got %u\n", ret );
+ ok( !luid.Info.Reserved, "got %x\n", luid.Info.Reserved );
+ ok( luid.Info.NetLuidIndex != 0xdead, "index not set\n" );
+ ok( luid.Info.IfType == IF_TYPE_ETHERNET_CSMACD, "got %u\n", luid.Info.IfType );
+
+ /* ConvertInterfaceLuidToNameW */
+ ret = pConvertInterfaceLuidToNameW( NULL, NULL, 0 );
+ ok( ret == ERROR_INVALID_PARAMETER, "got %u\n", ret );
+
+ ret = pConvertInterfaceLuidToNameW( &luid, NULL, 0 );
+ ok( ret == ERROR_INVALID_PARAMETER, "got %u\n", ret );
+
+ ret = pConvertInterfaceLuidToNameW( NULL, nameW, 0 );
+ ok( ret == ERROR_INVALID_PARAMETER, "got %u\n", ret );
+
+ ret = pConvertInterfaceLuidToNameW( &luid, nameW, 0 );
+ ok( ret == ERROR_NOT_ENOUGH_MEMORY, "got %u\n", ret );
+
+ nameW[0] = 0;
+ len = sizeof(nameW)/sizeof(nameW[0]);
+ ret = pConvertInterfaceLuidToNameW( &luid, nameW, len );
+ ok( !ret, "got %u\n", ret );
+ ok( nameW[0], "name not set\n" );
+
+ /* ConvertInterfaceLuidToNameA */
+ ret = pConvertInterfaceLuidToNameA( NULL, NULL, 0 );
+ ok( ret == ERROR_INVALID_PARAMETER, "got %u\n", ret );
+
+ ret = pConvertInterfaceLuidToNameA( &luid, NULL, 0 );
+ ok( ret == ERROR_NOT_ENOUGH_MEMORY, "got %u\n", ret );
+
+ ret = pConvertInterfaceLuidToNameA( NULL, nameA, 0 );
+ ok( ret == ERROR_INVALID_PARAMETER, "got %u\n", ret );
+
+ ret = pConvertInterfaceLuidToNameA( &luid, nameA, 0 );
+ ok( ret == ERROR_NOT_ENOUGH_MEMORY, "got %u\n", ret );
+
+ nameA[0] = 0;
+ len = sizeof(nameA)/sizeof(nameA[0]);
+ ret = pConvertInterfaceLuidToNameA( &luid, nameA, len );
+ ok( !ret, "got %u\n", ret );
+ ok( nameA[0], "name not set\n" );
+
+ /* ConvertInterfaceNameToLuidW */
+ ret = pConvertInterfaceNameToLuidW( NULL, NULL );
+ ok( ret == ERROR_INVALID_PARAMETER, "got %u\n", ret );
+
+ luid.Info.Reserved = luid.Info.NetLuidIndex = luid.Info.IfType = 0xdead;
+ ret = pConvertInterfaceNameToLuidW( NULL, &luid );
+ ok( ret == ERROR_INVALID_NAME, "got %u\n", ret );
+ ok( !luid.Info.Reserved, "got %x\n", luid.Info.Reserved );
+ ok( luid.Info.NetLuidIndex != 0xdead, "index not set\n" );
+ ok( !luid.Info.IfType, "got %u\n", luid.Info.IfType );
+
+ ret = pConvertInterfaceNameToLuidW( nameW, NULL );
+ ok( ret == ERROR_INVALID_PARAMETER, "got %u\n", ret );
+
+ luid.Info.Reserved = luid.Info.NetLuidIndex = luid.Info.IfType = 0xdead;
+ ret = pConvertInterfaceNameToLuidW( nameW, &luid );
+ ok( !ret, "got %u\n", ret );
+ ok( !luid.Info.Reserved, "got %x\n", luid.Info.Reserved );
+ ok( luid.Info.NetLuidIndex != 0xdead, "index not set\n" );
+ ok( luid.Info.IfType == IF_TYPE_ETHERNET_CSMACD, "got %u\n", luid.Info.IfType );
+
+ /* ConvertInterfaceNameToLuidA */
+ ret = pConvertInterfaceNameToLuidA( NULL, NULL );
+ ok( ret == ERROR_INVALID_NAME, "got %u\n", ret );
+
+ luid.Info.Reserved = luid.Info.NetLuidIndex = luid.Info.IfType = 0xdead;
+ ret = pConvertInterfaceNameToLuidA( NULL, &luid );
+ ok( ret == ERROR_INVALID_NAME, "got %u\n", ret );
+ ok( luid.Info.Reserved == 0xdead, "reserved set\n" );
+ ok( luid.Info.NetLuidIndex == 0xdead, "index set\n" );
+ ok( luid.Info.IfType == 0xdead, "type set\n" );
+
+ ret = pConvertInterfaceNameToLuidA( nameA, NULL );
+ ok( ret == ERROR_INVALID_PARAMETER, "got %u\n", ret );
+
+ luid.Info.Reserved = luid.Info.NetLuidIndex = luid.Info.IfType = 0xdead;
+ ret = pConvertInterfaceNameToLuidA( nameA, &luid );
+ ok( !ret, "got %u\n", ret );
+ ok( !luid.Info.Reserved, "got %x\n", luid.Info.Reserved );
+ ok( luid.Info.NetLuidIndex != 0xdead, "index not set\n" );
+ ok( luid.Info.IfType == IF_TYPE_ETHERNET_CSMACD, "got %u\n", luid.Info.IfType );
+}
+
+static void test_GetIfEntry2(void)
+{
+ DWORD ret;
+ MIB_IF_ROW2 row;
+ NET_IFINDEX index;
+
+ if (!pGetIfEntry2)
+ {
+ win_skip( "GetIfEntry2 not available\n" );
+ return;
+ }
+ if (!(index = get_interface_index()))
+ {
+ skip( "no suitable interface found\n" );
+ return;
+ }
+
+ ret = pGetIfEntry2( NULL );
+ ok( ret == ERROR_INVALID_PARAMETER, "got %u\n", ret );
+
+ memset( &row, 0, sizeof(row) );
+ ret = pGetIfEntry2( &row );
+ ok( ret == ERROR_INVALID_PARAMETER, "got %u\n", ret );
+
+ memset( &row, 0, sizeof(row) );
+ row.InterfaceIndex = index;
+ ret = pGetIfEntry2( &row );
+ ok( ret == NO_ERROR, "got %u\n", ret );
+ ok( row.InterfaceIndex == index, "got %u\n", index );
+}
+
+static void test_GetIfTable2(void)
+{
+ DWORD ret;
+ MIB_IF_TABLE2 *table;
+
+ if (!pGetIfTable2)
+ {
+ win_skip( "GetIfTable2 not available\n" );
+ return;
+ }
+
+ table = NULL;
+ ret = pGetIfTable2( &table );
+ ok( ret == NO_ERROR, "got %u\n", ret );
+ ok( table != NULL, "table not set\n" );
+ pFreeMibTable( table );
+}
+
START_TEST(iphlpapi)
{
testWin2KFunctions();
test_GetAdaptersAddresses();
+ test_GetExtendedTcpTable();
+ test_GetExtendedUdpTable();
+ test_CreateSortedAddressPairs();
+ test_interface_identifier_conversion();
+ test_GetIfEntry2();
+ test_GetIfTable2();
freeIPHlpApi();
}
}
projects / reactos.git / blobdiff