GetPerTcp6ConnectionEStats 函数 (iphlpapi.h)
GetPerTcp6ConnectionEStats 函数检索 IPv6 TCP 连接的扩展统计信息。
语法
IPHLPAPI_DLL_LINKAGE ULONG GetPerTcp6ConnectionEStats(
PMIB_TCP6ROW Row,
TCP_ESTATS_TYPE EstatsType,
[out] PUCHAR Rw,
ULONG RwVersion,
ULONG RwSize,
[out] PUCHAR Ros,
ULONG RosVersion,
ULONG RosSize,
[out] PUCHAR Rod,
ULONG RodVersion,
ULONG RodSize
);
parameters
Row
指向 IPv6 TCP 连接的 MIB_TCP6ROW 结构的指针。
EstatsType
请求的 TCP 扩展统计信息的类型。 如果调用成功，此参数确定 在 Rw、 Rod 和 Ros 参数中返回的信息的数据和格式。
此参数可以是 Tcpestats.h 头文件中定义的 TCP_ESTATS_TYPE 枚举类型的值之一。
| 值 | 含义 |
|---|---|
|
此值请求 TCP 连接的 SYN 交换信息。
此枚举值仅提供只读静态信息。 如果 Ros 参数不为 NULL 且函数成功， 则 Ros 参数指向的缓冲区应包含 TCP_ESTATS_SYN_OPTS_ROS_v0 结构。 |
|
此值请求 TCP 连接的扩展数据传输信息。
此枚举值只能使用只读动态信息和读/写信息。 如果 Rw 参数不为 NULL 且函数成功， 则 Rw 参数指向的缓冲区应包含 TCP_ESTATS_DATA_RW_v0 结构。 如果为此 TCP 连接启用了扩展数据传输信息， Rod 参数不为 NULL，并且函数成功， Rod 参数指向的缓冲区应包含 TCP_ESTATS_DATA_ROD_v0 结构。 |
|
此值请求 TCP 连接的发送方拥塞。
) (只读静态、只读动态和读/写信息的所有三种类型的信息都可用于此枚举值。 如果 Rw 参数不为 NULL 且函数成功， 则 Rw 参数指向的缓冲区应包含 TCP_ESTATS_SND_CONG_RW_v0 结构。 如果 Ros 参数不为 NULL 且函数成功， 则 Ros 参数指向的缓冲区应包含 TCP_ESTATS_SND_CONG_ROS_v0 结构。 如果为此 TCP 连接启用了发送方拥塞信息， Rod 参数不为 NULL，并且函数成功， Rod 参数指向的缓冲区应包含 TCP_ESTATS_SND_CONG_ROD_v0 结构。 |
|
此值请求 TCP 连接的扩展路径度量信息。
此枚举值只能使用只读动态信息和读/写信息。 如果 Rw 参数不为 NULL 且函数成功， 则 Rw 参数指向的缓冲区应包含 TCP_ESTATS_PATH_RW_v0 结构。 如果为此 TCP 连接启用了扩展路径度量信息， Rod 参数不为 NULL，并且函数成功， Rod 参数指向的缓冲区应包含 TCP_ESTATS_PATH_ROD_v0 结构。 |
|
此值请求 TCP 连接的扩展输出队列信息。
此枚举值只能使用只读动态信息和读/写信息。 如果 Rw 参数不为 NULL 且函数成功，则 Rw 参数指向的缓冲区应包含 TCP_ESTATS_SEND_BUFF_RW_v0 结构。 如果为此 TCP 连接启用了扩展输出队列信息，则 Rod 参数不为 NULL，并且函数成功， Rod 参数指向的缓冲区应包含 TCP_ESTATS_SEND_BUFF_ROD_v0 结构。 |
|
此值请求 TCP 连接的扩展本地接收器信息。
此枚举值只能使用只读动态信息和读/写信息。 如果 Rw 参数不为 NULL 且函数成功， 则 Rw 参数指向的缓冲区应包含 TCP_ESTATS_REC_RW_v0 结构。 如果为此 TCP 连接启用了扩展的本地接收器信息， Rod 参数不为 NULL，并且函数成功， 则 Rod 参数指向的缓冲区应包含 TCP_ESTATS_REC_ROD_v0 结构。 |
|
此值请求 TCP 连接的扩展远程接收方信息。
此枚举值只能使用只读动态信息和读/写信息。 如果 Rw 参数不为 NULL 且函数成功， 则 Rw 参数指向的缓冲区应包含 TCP_ESTATS_OBS_REC_RW_v0 结构。 如果为此 TCP 连接启用了扩展远程接收器信息， Rod 参数不为 NULL，并且函数成功， Rod 参数指向的缓冲区应包含 TCP_ESTATS_OBS_REC_ROD_v0 结构。 |
|
此值请求带宽上的 TCP 连接的带宽估计统计信息。
此枚举值只能使用只读动态信息和读/写信息。 如果 Rw 参数不为 NULL 且函数成功， 则 Rw 参数指向的缓冲区应包含 TCP_ESTATS_BANDWIDTH_RW_v0 结构。 如果为此 TCP 连接启用了带宽估计统计信息， Rod 参数不为 NULL，并且函数成功， Rod 参数指向的缓冲区应包含 TCP_ESTATS_BANDWIDTH_ROD_v0 结构。 |
|
此值请求 TCP 连接的精细往返时间 (RTT) 估计统计信息。
此枚举值只能使用只读动态信息和读/写信息。 如果 Rw 参数不为 NULL 且函数成功，则 Rw 参数指向的缓冲区应包含 TCP_ESTATS_FINE_RTT_RW_v0 结构。 如果为此 TCP 连接启用了细粒度 RTT 估计统计信息， Rod 参数不为 NULL，并且函数成功， 则 Rod 参数指向的缓冲区应包含 TCP_ESTATS_FINE_RTT_ROD_v0 结构。 |
[out] Rw
指向用于接收读/写信息的缓冲区的指针。 如果应用程序不想检索 TCP 连接的读/写信息，此参数可能是 NULL 指针。
RwVersion
请求的读/写信息的版本。 当前支持的值为 0 的版本。
RwSize
Rw 参数指向的缓冲区的大小（以字节为单位）。
[out] Ros
指向用于接收只读静态信息的缓冲区的指针。 如果应用程序不想检索 TCP 连接的只读静态信息，此参数可能是 NULL 指针。
RosVersion
请求的只读静态信息的版本。 当前支持的值为 0 的版本。
RosSize
Ros 参数指向的缓冲区的大小（以字节为单位）。
[out] Rod
指向用于接收只读动态信息的缓冲区的指针。 如果应用程序不想检索 TCP 连接的只读动态信息，此参数可能是 NULL 指针。
RodVersion
请求的只读动态信息的版本。 当前支持的值为 0 的版本。
RodSize
Rod 参数指向的缓冲区的大小（以字节为单位）。
返回值
如果函数成功，则返回值NO_ERROR。
如果函数失败，则返回值为以下错误代码之一。
| 返回代码 | 说明 |
|---|---|
|
传递给函数的缓冲区太小。 如果 Rw、 Ros 或 Rod 参数指向的缓冲区不够大，无法接收数据，则返回此错误。 如果 Rw、Ros 或 Rod 参数指向的给定缓冲区之一为 NULL，但在关联的 RwSize、RosSize 或 RodSize 中指定了长度，则也会返回此错误。
此错误值在 Windows Vista 和 Windows Server 2008 上返回。 |
|
参数不正确。 如果 Row 参数为 NULL 指针，则返回此错误。 |
|
提供给请求操作的用户缓冲区无效。 如果 Rw、Ros 或 Rod 参数指向的给定缓冲区之一为 NULL，但在关联的 RwSize、RosSize 或 RodSize 中指定了长度，则返回此错误。 因此，如果满足以下任一条件，则返回此错误：
此错误值在 Windows 7 和 Windows Server 2008 R2 上返回。 |
|
找不到此请求的条目。 如果找不到 Row 参数中指定的 TCP 连接，则返回此错误。 |
|
不支持该请求。 如果 RwVersion、 RosVersion 或 RodVersion 参数未设置为零，则返回此错误。 |
|
使用 FormatMessage 获取返回错误的消息字符串。 |
注解
GetPerTcp6ConnectionEStats 函数在 Windows Vista 及更高版本上定义。
GetPerTcp6ConnectionEStats 函数旨在使用 TCP 诊断网络和应用程序中的性能问题。 如果基于网络的应用程序性能不佳，TCP 可以确定瓶颈是在发送方、接收方还是网络本身。 如果瓶颈在网络中，TCP 可以提供有关其性质的特定信息。
GetPerTcp6ConnectionEStats 函数检索 Row 参数中传递的 IPv6 TCP 连接的扩展统计信息。 检索的扩展统计信息的类型在 EstatsType 参数中指定。 以前必须通过调用 SetPerTcp6ConnectionEStats 函数为所有TCP_ESTATS_TYPE值启用此 TCP 连接的扩展统计信息，除非在 EstatsType 参数中传递 TcpConnectionEstatsSynOpts。
GetTcp6Table 函数用于检索本地计算机上的 IPv6 TCP 连接表。 此函数返回包含 MIB_TCP6ROW 项数组的 MIB_TCP6TABLE 结构。 传递给 GetPerTcp6ConnectionEStats 函数的 Row 参数必须是现有 IPv6 TCP 连接的条目。
当前支持的唯一 TCP 连接统计信息版本为版本零。 因此，传递给 GetPerTcp6ConnectionEStats 的RwVersion、RosVersion 和 RodVersion 参数应设置为 0。
有关 IPv4 连接上的扩展 TCP 统计信息的信息，请参阅 GetPerTcpConnectionEStats 和 SetPerTcpConnectionEStats 函数。
SetPerTcp6ConnectionEStats 函数只能由以 Administrators 组成员身份登录的用户调用。 如果 SetPerTcp6ConnectionEStats 由不是 Administrators 组成员的用户调用，则函数调用将失败并返回 ERROR_ACCESS_DENIED 。 此函数也可能因为 Windows Vista 及更高版本上的用户帐户控制 (UAC) 而失败。 如果包含此函数的应用程序由以管理员组成员身份登录（而不是内置管理员）的用户执行，则此调用将失败，除非应用程序已在清单文件中标记为 requestedExecutionLevel 设置为 requireAdministrator。 如果应用程序缺少此清单文件，则作为管理员组成员（而不是内置管理员）登录的用户必须在增强的 shell 中执行应用程序，因为内置管理员 (RunAs 管理员) 此函数才能成功。
GetPerTcp6ConnectionEStats 的调用方应在返回的 Rw 结构中检查 EnableCollection 字段，如果不是 TRUE，则调用方应忽略 Ros 和 Rod 结构中的数据。 如果 EnableCollection 设置为 FALSE，则 Ros 和 Rod 中返回的数据未定义。 例如，发生此情况的一个条件是，使用 GetPerTcp6ConnectionEStats 检索 IPv6 TCP 连接的扩展统计信息，并且之前调用 SetPerTcp6ConnectionEStats 来启用扩展统计信息。 如果 SetPerTcp6ConnectionEStats 调用失败，则对 GetPerTcp6ConnectionEStats 的 后续调用将返回无意义的随机数据，而不是扩展的 TCP 统计信息。 可以通过以管理员和普通用户身份运行以下示例来观察该示例。
示例
以下示例检索 IPv4 和 IPv6 TCP 连接的 TCP 扩展统计信息，并从返回的数据中输出值。
// Need to link with Iphlpapi.lib and Ws2_32.lib
// Need to run as administrator
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include <windows.h>
#include <winsock2.h>
#include <Ws2tcpip.h>
#include <iphlpapi.h>
#include <Tcpestats.h>
#include <stdlib.h>
#include <stdio.h>
// Need to link with Iphlpapi.lib
#pragma comment(lib, "iphlpapi.lib")
// Need to link with Ws2_32.lib
#pragma comment(lib, "ws2_32.lib")
// An array of name for the TCP_ESTATS_TYPE enum values
// The names values must match the enum values
const wchar_t* estatsTypeNames[] = {
L"TcpConnectionEstatsSynOpts",
L"TcpConnectionEstatsData",
L"TcpConnectionEstatsSndCong",
L"TcpConnectionEstatsPath",
L"TcpConnectionEstatsSendBuff",
L"TcpConnectionEstatsRec",
L"TcpConnectionEstatsObsRec",
L"TcpConnectionEstatsBandwidth",
L"TcpConnectionEstatsFineRtt",
L"TcpConnectionEstatsMaximum"
};
// Function prototypes
// Run tests for IPv4 or IPv4 TCP extended stats
DWORD RunEstatsTest(bool v6);
// Get an IPv4 TCP row entry
DWORD GetTcpRow(u_short localPort, u_short remotePort,
MIB_TCP_STATE state, __out PMIB_TCPROW row);
// Get an IPv6 TCP row entry
DWORD GetTcp6Row(u_short localPort, u_short remotePort,
MIB_TCP_STATE state, __out PMIB_TCP6ROW row);
// Enable or disable the supplied Estat type on a TCP connection
void ToggleEstat(PVOID row, TCP_ESTATS_TYPE type, bool enable, bool v6);
// Toggle all Estats for a TCP connection
void ToggleAllEstats(void* row, bool enable, bool v6);
// Dump the supplied Estate type data on the given TCP connection row
void GetAndOutputEstats(void* row, TCP_ESTATS_TYPE type, bool v6);
//
void GetAllEstats(void* row, bool v6);
// Creates a TCP server and client socket on the loopback address.
// Binds the server socket to a port.
// Establishes a client TCP connection to the server
int CreateTcpConnection(bool v6, SOCKET* serviceSocket, SOCKET* clientSocket,
SOCKET* acceptSocket, u_short* serverPort,
u_short* clientPort);
//
// Entry point.
//
int __cdecl main()
{
RunEstatsTest(FALSE);
RunEstatsTest(TRUE);
return (0);
}
//
// Create connect and listen sockets on loopback interface and dump all Estats
// types on the created TCP connections for the supplied IP address type.
//
DWORD RunEstatsTest(bool v6)
{
SOCKET serviceSocket, clientSocket, acceptSocket;
serviceSocket = clientSocket = acceptSocket = INVALID_SOCKET;
MIB_TCPROW server4ConnectRow, client4ConnectRow;
MIB_TCP6ROW server6ConnectRow, client6ConnectRow;
void* serverConnectRow, * clientConnectRow = NULL;
bool bWSAStartup = false;
char* buff = (char*)malloc(1000);
if (buff == NULL) {
wprintf(L"\nFailed to allocate memory.");
goto bail;
}
if (v6) {
serverConnectRow = &server6ConnectRow;
clientConnectRow = &client6ConnectRow;
}
else {
serverConnectRow = &server4ConnectRow;
clientConnectRow = &client4ConnectRow;
}
UINT winStatus;
int sockStatus;
u_short serverPort, clientPort;
//
// Initialize Winsock.
//
WSADATA wsaData;
winStatus = WSAStartup(MAKEWORD(2, 2), &wsaData);
if (winStatus != ERROR_SUCCESS) {
wprintf(L"\nFailed to open winsock. Error %d", winStatus);
goto bail;
}
bWSAStartup = true;
//
// Create TCP connection on which Estats information will be collected.
// Obtain port numbers of created connections.
//
winStatus =
CreateTcpConnection(v6, &serviceSocket, &clientSocket, &acceptSocket,
&serverPort, &clientPort);
if (winStatus != ERROR_SUCCESS) {
wprintf(L"\nFailed to create TCP connection. Error %d", winStatus);
goto bail;
}
//
// Obtain MIB_TCPROW corresponding to the TCP connection.
//
winStatus = v6 ?
GetTcp6Row(serverPort, clientPort, MIB_TCP_STATE_ESTAB,
(PMIB_TCP6ROW)serverConnectRow) :
GetTcpRow(serverPort, clientPort, MIB_TCP_STATE_ESTAB,
(PMIB_TCPROW)serverConnectRow);
if (winStatus != ERROR_SUCCESS) {
wprintf
(L"\nGetTcpRow failed on the server established connection with %d",
winStatus);
goto bail;
}
winStatus = v6 ?
GetTcp6Row(clientPort, serverPort, MIB_TCP_STATE_ESTAB,
(PMIB_TCP6ROW)clientConnectRow) :
GetTcpRow(clientPort, serverPort, MIB_TCP_STATE_ESTAB,
(PMIB_TCPROW)clientConnectRow);
if (winStatus != ERROR_SUCCESS) {
wprintf
(L"\nGetTcpRow failed on the client established connection with %d",
winStatus);
goto bail;
}
//
// Enable Estats collection and dump current stats.
//
ToggleAllEstats(serverConnectRow, TRUE, v6);
ToggleAllEstats(clientConnectRow, TRUE, v6);
wprintf(L"\n\n\nDumping Estats for server socket:\n");
GetAllEstats(serverConnectRow, v6);
wprintf(L"\n\n\nDumping Estats for client connect socket:\n");
GetAllEstats(clientConnectRow, v6);
//
// Initiate TCP data transfers to see effect on Estats counters.
//
sockStatus = send(clientSocket, buff, (int)(1000 * sizeof(char)), 0);
if (sockStatus == SOCKET_ERROR) {
wprintf(L"\nFailed to send from client to server %d",
WSAGetLastError());
}
else {
sockStatus = recv(acceptSocket, buff, (int)(1000 * sizeof(char)), 0);
if (sockStatus == SOCKET_ERROR) {
wprintf(L"\nFailed to receive data on the server %d",
WSAGetLastError());
}
}
//
// Dump updated Estats and disable Estats collection.
//
wprintf
(L"\n\n\nDumping Estats for server socket after client sends data:\n");
GetAllEstats(serverConnectRow, v6);
wprintf
(L"\n\n\nDumping Estats for client socket after client sends data:\n");
GetAllEstats(clientConnectRow, v6);
ToggleAllEstats(serverConnectRow, FALSE, v6);
ToggleAllEstats(clientConnectRow, FALSE, v6);
bail:
if (serviceSocket != INVALID_SOCKET)
closesocket(serviceSocket);
if (clientSocket != INVALID_SOCKET)
closesocket(clientSocket);
if (acceptSocket != INVALID_SOCKET)
closesocket(acceptSocket);
if (buff != NULL)
free(buff);
if (bWSAStartup)
WSACleanup();
return ERROR_SUCCESS;
}
int CreateTcpConnection(bool v6,
SOCKET* serviceSocket,
SOCKET* clientSocket,
SOCKET* acceptSocket,
u_short* serverPort, u_short* clientPort)
{
INT status;
ADDRINFOW hints, * localhost = NULL;
const wchar_t* loopback;
loopback = v6 ? L"::1" : L"127.0.0.1";
int aiFamily = v6 ? AF_INET6 : AF_INET;
int nameLen = sizeof(SOCKADDR_STORAGE);
*serviceSocket = INVALID_SOCKET;
*clientSocket = INVALID_SOCKET;
*acceptSocket = INVALID_SOCKET;
ZeroMemory(&hints, sizeof(hints));
hints.ai_family = aiFamily;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
status = GetAddrInfoW(loopback, L"", &hints, &localhost);
if (status != ERROR_SUCCESS) {
wprintf(L"\nFailed to open localhost. Error %d", status);
goto bail;
}
*serviceSocket = socket(aiFamily, SOCK_STREAM, IPPROTO_TCP);
if (*serviceSocket == INVALID_SOCKET) {
wprintf(L"\nFailed to create server socket. Error %d",
WSAGetLastError());
goto bail;
}
*clientSocket = socket(aiFamily, SOCK_STREAM, IPPROTO_TCP);
if (*clientSocket == INVALID_SOCKET) {
wprintf(L"\nFailed to create client socket. Error %d",
WSAGetLastError());
goto bail;
}
status =
bind(*serviceSocket, localhost->ai_addr, (int)localhost->ai_addrlen);
if (status == SOCKET_ERROR) {
wprintf(L"\nFailed to bind server socket to loopback. Error %d",
WSAGetLastError());
goto bail;
}
if (localhost != NULL) {
FreeAddrInfoW(localhost);
localhost = NULL;
}
SOCKADDR_STORAGE serverSockName, clientSockName;
status = getsockname(*serviceSocket,
(sockaddr*)&serverSockName, &nameLen);
if (status == SOCKET_ERROR) {
wprintf(L"\ngetsockname failed %d", WSAGetLastError());
goto bail;
}
if (v6) {
*serverPort = ((sockaddr_in6*)(&serverSockName))->sin6_port;
}
else {
*serverPort = ((sockaddr_in*)(&serverSockName))->sin_port;
}
status = listen(*serviceSocket, SOMAXCONN);
if (status == SOCKET_ERROR) {
wprintf(L"\nFailed to listen on server socket. Error %d",
WSAGetLastError());
goto bail;
}
status =
connect(*clientSocket, (sockaddr*)&serverSockName,
(int)sizeof(SOCKADDR_STORAGE));
if (status == SOCKET_ERROR) {
wprintf(L"\nCould not connect client and server sockets %d",
WSAGetLastError());
goto bail;
}
status = getsockname(*clientSocket,
(sockaddr*)&clientSockName, &nameLen);
if (status == SOCKET_ERROR) {
wprintf(L"\ngetsockname failed %d", WSAGetLastError());
goto bail;
}
if (v6) {
*clientPort = ((sockaddr_in6*)(&clientSockName))->sin6_port;
}
else {
*clientPort = ((sockaddr_in*)(&clientSockName))->sin_port;
}
*acceptSocket = accept(*serviceSocket, NULL, NULL);
if (*acceptSocket == INVALID_SOCKET) {
wprintf(L"\nFailed to accept socket connection %d", WSAGetLastError());
goto bail;
}
return ERROR_SUCCESS;
bail:
if (localhost != NULL)
FreeAddrInfoW(localhost);
if (*serviceSocket != INVALID_SOCKET) {
closesocket(*serviceSocket);
*serviceSocket = INVALID_SOCKET;
}
if (*clientSocket != INVALID_SOCKET) {
closesocket(*clientSocket);
*clientSocket = INVALID_SOCKET;
}
if (*acceptSocket != INVALID_SOCKET) {
closesocket(*acceptSocket);
*acceptSocket = INVALID_SOCKET;
}
return status;
}
void GetAllEstats(void* row, bool v6)
{
GetAndOutputEstats(row, TcpConnectionEstatsSynOpts, v6);
GetAndOutputEstats(row, TcpConnectionEstatsData, v6);
GetAndOutputEstats(row, TcpConnectionEstatsSndCong, v6);
GetAndOutputEstats(row, TcpConnectionEstatsPath, v6);
GetAndOutputEstats(row, TcpConnectionEstatsSendBuff, v6);
GetAndOutputEstats(row, TcpConnectionEstatsRec, v6);
GetAndOutputEstats(row, TcpConnectionEstatsObsRec, v6);
GetAndOutputEstats(row, TcpConnectionEstatsBandwidth, v6);
GetAndOutputEstats(row, TcpConnectionEstatsFineRtt, v6);
}
//
// Returns a MIB_TCPROW corresponding to the local port, remote port and state
// filter parameters.
//
DWORD
GetTcpRow(u_short localPort,
u_short remotePort, MIB_TCP_STATE state, __out PMIB_TCPROW row)
{
PMIB_TCPTABLE tcpTable = NULL;
PMIB_TCPROW tcpRowIt = NULL;
DWORD status, size = 0, i;
bool connectionFound = FALSE;
status = GetTcpTable(tcpTable, &size, TRUE);
if (status != ERROR_INSUFFICIENT_BUFFER) {
return status;
}
tcpTable = (PMIB_TCPTABLE)malloc(size);
if (tcpTable == NULL) {
return ERROR_OUTOFMEMORY;
}
status = GetTcpTable(tcpTable, &size, TRUE);
if (status != ERROR_SUCCESS) {
free(tcpTable);
return status;
}
for (i = 0; i < tcpTable->dwNumEntries; i++) {
tcpRowIt = &tcpTable->table[i];
if (tcpRowIt->dwLocalPort == (DWORD)localPort &&
tcpRowIt->dwRemotePort == (DWORD)remotePort &&
tcpRowIt->State == state) {
connectionFound = TRUE;
*row = *tcpRowIt;
break;
}
}
free(tcpTable);
if (connectionFound) {
return ERROR_SUCCESS;
}
else {
return ERROR_NOT_FOUND;
}
}
//
// Returns a MIB_TCP6ROW corresponding to the local port, remote port and state
// filter parameters. This is a v6 equivalent of the GetTcpRow function.
//
DWORD
GetTcp6Row(u_short localPort,
u_short remotePort, MIB_TCP_STATE state, __out PMIB_TCP6ROW row)
{
PMIB_TCP6TABLE tcp6Table = NULL;
PMIB_TCP6ROW tcp6RowIt = NULL;
DWORD status, size = 0, i;
bool connectionFound = FALSE;
status = GetTcp6Table(tcp6Table, &size, TRUE);
if (status != ERROR_INSUFFICIENT_BUFFER) {
return status;
}
tcp6Table = (PMIB_TCP6TABLE)malloc(size);
if (tcp6Table == NULL) {
return ERROR_OUTOFMEMORY;
}
status = GetTcp6Table(tcp6Table, &size, TRUE);
if (status != ERROR_SUCCESS) {
free(tcp6Table);
return status;
}
for (i = 0; i < tcp6Table->dwNumEntries; i++) {
tcp6RowIt = &tcp6Table->table[i];
if (tcp6RowIt->dwLocalPort == (DWORD)localPort &&
tcp6RowIt->dwRemotePort == (DWORD)remotePort &&
tcp6RowIt->State == state) {
connectionFound = TRUE;
*row = *tcp6RowIt;
break;
}
}
free(tcp6Table);
if (connectionFound) {
return ERROR_SUCCESS;
}
else {
return ERROR_NOT_FOUND;
}
}
//
// Enable or disable the supplied Estat type on a TCP connection.
//
void ToggleEstat(PVOID row, TCP_ESTATS_TYPE type, bool enable, bool v6)
{
TCP_BOOLEAN_OPTIONAL operation =
enable ? TcpBoolOptEnabled : TcpBoolOptDisabled;
ULONG status, size = 0;
PUCHAR rw = NULL;
TCP_ESTATS_DATA_RW_v0 dataRw;
TCP_ESTATS_SND_CONG_RW_v0 sndRw;
TCP_ESTATS_PATH_RW_v0 pathRw;
TCP_ESTATS_SEND_BUFF_RW_v0 sendBuffRw;
TCP_ESTATS_REC_RW_v0 recRw;
TCP_ESTATS_OBS_REC_RW_v0 obsRecRw;
TCP_ESTATS_BANDWIDTH_RW_v0 bandwidthRw;
TCP_ESTATS_FINE_RTT_RW_v0 fineRttRw;
switch (type) {
case TcpConnectionEstatsData:
dataRw.EnableCollection = enable;
rw = (PUCHAR)&dataRw;
size = sizeof(TCP_ESTATS_DATA_RW_v0);
break;
case TcpConnectionEstatsSndCong:
sndRw.EnableCollection = enable;
rw = (PUCHAR)&sndRw;
size = sizeof(TCP_ESTATS_SND_CONG_RW_v0);
break;
case TcpConnectionEstatsPath:
pathRw.EnableCollection = enable;
rw = (PUCHAR)&pathRw;
size = sizeof(TCP_ESTATS_PATH_RW_v0);
break;
case TcpConnectionEstatsSendBuff:
sendBuffRw.EnableCollection = enable;
rw = (PUCHAR)&sendBuffRw;
size = sizeof(TCP_ESTATS_SEND_BUFF_RW_v0);
break;
case TcpConnectionEstatsRec:
recRw.EnableCollection = enable;
rw = (PUCHAR)&recRw;
size = sizeof(TCP_ESTATS_REC_RW_v0);
break;
case TcpConnectionEstatsObsRec:
obsRecRw.EnableCollection = enable;
rw = (PUCHAR)&obsRecRw;
size = sizeof(TCP_ESTATS_OBS_REC_RW_v0);
break;
case TcpConnectionEstatsBandwidth:
bandwidthRw.EnableCollectionInbound = operation;
bandwidthRw.EnableCollectionOutbound = operation;
rw = (PUCHAR)&bandwidthRw;
size = sizeof(TCP_ESTATS_BANDWIDTH_RW_v0);
break;
case TcpConnectionEstatsFineRtt:
fineRttRw.EnableCollection = enable;
rw = (PUCHAR)&fineRttRw;
size = sizeof(TCP_ESTATS_FINE_RTT_RW_v0);
break;
default:
return;
break;
}
if (v6) {
status = SetPerTcp6ConnectionEStats((PMIB_TCP6ROW)row, type,
rw, 0, size, 0);
}
else {
status = SetPerTcpConnectionEStats((PMIB_TCPROW)row, type,
rw, 0, size, 0);
}
if (status != NO_ERROR) {
if (v6)
wprintf(L"\nSetPerTcp6ConnectionEStats %s %s failed. status = %d",
estatsTypeNames[type], enable ? L"enabled" : L"disabled",
status);
else
wprintf(L"\nSetPerTcpConnectionEStats %s %s failed. status = %d",
estatsTypeNames[type], enable ? L"enabled" : L"disabled",
status);
}
}
//
// Toggle all Estats for a TCP connection.
//
void ToggleAllEstats(void* row, bool enable, bool v6)
{
ToggleEstat(row, TcpConnectionEstatsData, enable, v6);
ToggleEstat(row, TcpConnectionEstatsSndCong, enable, v6);
ToggleEstat(row, TcpConnectionEstatsPath, enable, v6);
ToggleEstat(row, TcpConnectionEstatsSendBuff, enable, v6);
ToggleEstat(row, TcpConnectionEstatsRec, enable, v6);
ToggleEstat(row, TcpConnectionEstatsObsRec, enable, v6);
ToggleEstat(row, TcpConnectionEstatsBandwidth, enable, v6);
ToggleEstat(row, TcpConnectionEstatsFineRtt, enable, v6);
}
//
// Call GetPerTcp6ConnectionEStats or GetPerTcpConnectionEStats.
//
ULONG GetConnectionEStats(void* row, TCP_ESTATS_TYPE type, PUCHAR rw, ULONG rwSize, bool v6, PUCHAR ros, ULONG rosSize, PUCHAR rod, ULONG rodSize)
{
if (v6) {
return GetPerTcp6ConnectionEStats((PMIB_TCP6ROW)row,
type,
rw, 0, rwSize,
ros, 0, rosSize,
rod, 0, rodSize);
}
else {
return GetPerTcpConnectionEStats((PMIB_TCPROW)row,
type,
rw, 0, rwSize,
ros, 0, rosSize,
rod, 0, rodSize);
}
}
//
// Dump the supplied Estate type on the given TCP connection row.
//
void GetAndOutputEstats(void* row, TCP_ESTATS_TYPE type, bool v6)
{
ULONG rosSize = 0, rodSize = 0;
ULONG winStatus;
PUCHAR ros = NULL, rod = NULL;
PTCP_ESTATS_SYN_OPTS_ROS_v0 synOptsRos = { 0 };
PTCP_ESTATS_DATA_ROD_v0 dataRod = { 0 };
PTCP_ESTATS_SND_CONG_ROD_v0 sndCongRod = { 0 };
PTCP_ESTATS_SND_CONG_ROS_v0 sndCongRos = { 0 };
PTCP_ESTATS_PATH_ROD_v0 pathRod = { 0 };
PTCP_ESTATS_SEND_BUFF_ROD_v0 sndBuffRod = { 0 };
PTCP_ESTATS_REC_ROD_v0 recRod = { 0 };
PTCP_ESTATS_OBS_REC_ROD_v0 obsRecRod = { 0 };
PTCP_ESTATS_BANDWIDTH_ROD_v0 bandwidthRod = { 0 };
PTCP_ESTATS_FINE_RTT_ROD_v0 fineRttRod = { 0 };
switch (type) {
case TcpConnectionEstatsSynOpts:
rosSize = sizeof(TCP_ESTATS_SYN_OPTS_ROS_v0);
break;
case TcpConnectionEstatsData:
rodSize = sizeof(TCP_ESTATS_DATA_ROD_v0);
break;
case TcpConnectionEstatsSndCong:
rodSize = sizeof(TCP_ESTATS_SND_CONG_ROD_v0);
rosSize = sizeof(TCP_ESTATS_SND_CONG_ROS_v0);
break;
case TcpConnectionEstatsPath:
rodSize = sizeof(TCP_ESTATS_PATH_ROD_v0);
break;
case TcpConnectionEstatsSendBuff:
rodSize = sizeof(TCP_ESTATS_SEND_BUFF_ROD_v0);
break;
case TcpConnectionEstatsRec:
rodSize = sizeof(TCP_ESTATS_REC_ROD_v0);
break;
case TcpConnectionEstatsObsRec:
rodSize = sizeof(TCP_ESTATS_OBS_REC_ROD_v0);
break;
case TcpConnectionEstatsBandwidth:
rodSize = sizeof(TCP_ESTATS_BANDWIDTH_ROD_v0);
break;
case TcpConnectionEstatsFineRtt:
rodSize = sizeof(TCP_ESTATS_FINE_RTT_ROD_v0);
break;
default:
wprintf(L"\nCannot get type %d", (int)type);
return;
break;
}
if (rosSize != 0) {
ros = (PUCHAR)malloc(rosSize);
if (ros == NULL) {
wprintf(L"\nOut of memory");
return;
}
else
memset(ros, 0, rosSize); // zero the buffer
}
if (rodSize != 0) {
rod = (PUCHAR)malloc(rodSize);
if (rod == NULL) {
free(ros);
wprintf(L"\nOut of memory");
return;
}
else
memset(rod, 0, rodSize); // zero the buffer
}
TCP_ESTATS_DATA_RW_v0 dataRw = { 0 };
TCP_ESTATS_SND_CONG_RW_v0 sndCongRw = { 0 };
TCP_ESTATS_PATH_RW_v0 pathRw = { 0 };
TCP_ESTATS_SEND_BUFF_RW_v0 sndBuffRw = { 0 };
TCP_ESTATS_REC_RW_v0 recRw = { 0 };
TCP_ESTATS_OBS_REC_RW_v0 obsRecRw = { 0 };
TCP_ESTATS_BANDWIDTH_RW_v0 bandwidthRw = { 0 };
TCP_ESTATS_FINE_RTT_RW_v0 fineRttRw = { 0 };
BOOLEAN RwEnableCollection{ FALSE };
switch (type) {
case TcpConnectionEstatsData:
winStatus = GetConnectionEStats(row, type, (PUCHAR)&dataRw, sizeof(TCP_ESTATS_DATA_RW_v0), v6, ros, rosSize, rod, rodSize);
RwEnableCollection = dataRw.EnableCollection;
break;
case TcpConnectionEstatsSndCong:
winStatus = GetConnectionEStats(row, type, (PUCHAR)&sndCongRw, sizeof(TCP_ESTATS_SND_CONG_RW_v0), v6, ros, rosSize, rod, rodSize);
RwEnableCollection = sndCongRw.EnableCollection;
break;
case TcpConnectionEstatsPath:
winStatus = GetConnectionEStats(row, type, (PUCHAR)&pathRw, sizeof(TCP_ESTATS_PATH_RW_v0), v6, ros, rosSize, rod, rodSize);
RwEnableCollection = pathRw.EnableCollection;
break;
case TcpConnectionEstatsSendBuff:
winStatus = GetConnectionEStats(row, type, (PUCHAR)&sndBuffRw, sizeof(TCP_ESTATS_SEND_BUFF_RW_v0), v6, ros, rosSize, rod, rodSize);
RwEnableCollection = sndBuffRw.EnableCollection;
break;
case TcpConnectionEstatsRec:
winStatus = GetConnectionEStats(row, type, (PUCHAR)&recRw, sizeof(TCP_ESTATS_REC_RW_v0), v6, ros, rosSize, rod, rodSize);
RwEnableCollection = recRw.EnableCollection;
break;
case TcpConnectionEstatsObsRec:
winStatus = GetConnectionEStats(row, type, (PUCHAR)&obsRecRw, sizeof(TCP_ESTATS_OBS_REC_RW_v0), v6, ros, rosSize, rod, rodSize);
RwEnableCollection = obsRecRw.EnableCollection;
break;
case TcpConnectionEstatsBandwidth:
winStatus = GetConnectionEStats(row, type, (PUCHAR)&bandwidthRw, sizeof(TCP_ESTATS_BANDWIDTH_RW_v0), v6, ros, rosSize, rod, rodSize);
RwEnableCollection = bandwidthRw.EnableCollectionOutbound && bandwidthRw.EnableCollectionInbound;
break;
case TcpConnectionEstatsFineRtt:
winStatus = GetConnectionEStats(row, type, (PUCHAR)&fineRttRw, sizeof(TCP_ESTATS_FINE_RTT_RW_v0), v6, ros, rosSize, rod, rodSize);
RwEnableCollection = fineRttRw.EnableCollection;
break;
default:
winStatus = GetConnectionEStats(row, type, NULL, v6, 0, ros, rosSize, rod, rodSize);
break;
}
if (!RwEnableCollection) {
if (v6)
wprintf(L"\nGetPerTcp6ConnectionEStats %s failed. Rw.EnableCollection == FALSE", estatsTypeNames[type]);
else
wprintf(L"\nGetPerTcpConnectionEStats %s failed. Rw.EnableCollection == FALSE", estatsTypeNames[type]);
return;
}
if (winStatus != NO_ERROR) {
if (v6)
wprintf(L"\nGetPerTcp6ConnectionEStats %s failed. status = %d",
estatsTypeNames[type],
winStatus);
else
wprintf(L"\nGetPerTcpConnectionEStats %s failed. status = %d",
estatsTypeNames[type],
winStatus);
}
else {
switch (type) {
case TcpConnectionEstatsSynOpts:
synOptsRos = (PTCP_ESTATS_SYN_OPTS_ROS_v0)ros;
wprintf(L"\nSyn Opts");
wprintf(L"\nActive Open: %s",
synOptsRos->ActiveOpen ? L"Yes" : L"No");
wprintf(L"\nMss Received: %u", synOptsRos->MssRcvd);
wprintf(L"\nMss Sent %u", synOptsRos->MssSent);
break;
case TcpConnectionEstatsData:
dataRod = (PTCP_ESTATS_DATA_ROD_v0)rod;
wprintf(L"\n\nData");
wprintf(L"\nBytes Out: %lu", dataRod->DataBytesOut);
wprintf(L"\nSegs Out: %lu", dataRod->DataSegsOut);
wprintf(L"\nBytes In: %lu", dataRod->DataBytesIn);
wprintf(L"\nSegs In: %lu", dataRod->DataSegsIn);
wprintf(L"\nSegs Out: %u", dataRod->SegsOut);
wprintf(L"\nSegs In: %u", dataRod->SegsIn);
wprintf(L"\nSoft Errors: %u", dataRod->SoftErrors);
wprintf(L"\nSoft Error Reason: %u", dataRod->SoftErrorReason);
wprintf(L"\nSnd Una: %u", dataRod->SndUna);
wprintf(L"\nSnd Nxt: %u", dataRod->SndNxt);
wprintf(L"\nSnd Max: %u", dataRod->SndMax);
wprintf(L"\nBytes Acked: %lu", dataRod->ThruBytesAcked);
wprintf(L"\nRcv Nxt: %u", dataRod->RcvNxt);
wprintf(L"\nBytes Rcv: %lu", dataRod->ThruBytesReceived);
break;
case TcpConnectionEstatsSndCong:
sndCongRod = (PTCP_ESTATS_SND_CONG_ROD_v0)rod;
sndCongRos = (PTCP_ESTATS_SND_CONG_ROS_v0)ros;
wprintf(L"\n\nSnd Cong");
wprintf(L"\nTrans Rwin: %u", sndCongRod->SndLimTransRwin);
wprintf(L"\nLim Time Rwin: %u", sndCongRod->SndLimTimeRwin);
wprintf(L"\nLim Bytes Rwin: %u", sndCongRod->SndLimBytesRwin);
wprintf(L"\nLim Trans Cwnd: %u", sndCongRod->SndLimTransCwnd);
wprintf(L"\nLim Time Cwnd: %u", sndCongRod->SndLimTimeCwnd);
wprintf(L"\nLim Bytes Cwnd: %u", sndCongRod->SndLimBytesCwnd);
wprintf(L"\nLim Trans Snd: %u", sndCongRod->SndLimTransSnd);
wprintf(L"\nLim Time Snd: %u", sndCongRod->SndLimTimeSnd);
wprintf(L"\nLim Bytes Snd: %u", sndCongRod->SndLimBytesSnd);
wprintf(L"\nSlow Start: %u", sndCongRod->SlowStart);
wprintf(L"\nCong Avoid: %u", sndCongRod->CongAvoid);
wprintf(L"\nOther Reductions: %u", sndCongRod->OtherReductions);
wprintf(L"\nCur Cwnd: %u", sndCongRod->CurCwnd);
wprintf(L"\nMax Ss Cwnd: %u", sndCongRod->MaxSsCwnd);
wprintf(L"\nMax Ca Cwnd: %u", sndCongRod->MaxCaCwnd);
wprintf(L"\nCur Ss Thresh: 0x%x (%u)", sndCongRod->CurSsthresh,
sndCongRod->CurSsthresh);
wprintf(L"\nMax Ss Thresh: 0x%x (%u)", sndCongRod->MaxSsthresh,
sndCongRod->MaxSsthresh);
wprintf(L"\nMin Ss Thresh: 0x%x (%u)", sndCongRod->MinSsthresh,
sndCongRod->MinSsthresh);
wprintf(L"\nLim Cwnd: 0x%x (%u)", sndCongRos->LimCwnd,
sndCongRos->LimCwnd);
break;
case TcpConnectionEstatsPath:
pathRod = (PTCP_ESTATS_PATH_ROD_v0)rod;
wprintf(L"\n\nPath");
wprintf(L"\nFast Retran: %u", pathRod->FastRetran);
wprintf(L"\nTimeouts: %u", pathRod->Timeouts);
wprintf(L"\nSubsequent Timeouts: %u", pathRod->SubsequentTimeouts);
wprintf(L"\nCur Timeout Count: %u", pathRod->CurTimeoutCount);
wprintf(L"\nAbrupt Timeouts: %u", pathRod->AbruptTimeouts);
wprintf(L"\nPkts Retrans: %u", pathRod->PktsRetrans);
wprintf(L"\nBytes Retrans: %u", pathRod->BytesRetrans);
wprintf(L"\nDup Acks In: %u", pathRod->DupAcksIn);
wprintf(L"\nSacksRcvd: %u", pathRod->SacksRcvd);
wprintf(L"\nSack Blocks Rcvd: %u", pathRod->SackBlocksRcvd);
wprintf(L"\nCong Signals: %u", pathRod->CongSignals);
wprintf(L"\nPre Cong Sum Cwnd: %u", pathRod->PreCongSumCwnd);
wprintf(L"\nPre Cong Sum Rtt: %u", pathRod->PreCongSumRtt);
wprintf(L"\nPost Cong Sum Rtt: %u", pathRod->PostCongSumRtt);
wprintf(L"\nPost Cong Count Rtt: %u", pathRod->PostCongCountRtt);
wprintf(L"\nEcn Signals: %u", pathRod->EcnSignals);
wprintf(L"\nEce Rcvd: %u", pathRod->EceRcvd);
wprintf(L"\nSend Stall: %u", pathRod->SendStall);
wprintf(L"\nQuench Rcvd: %u", pathRod->QuenchRcvd);
wprintf(L"\nRetran Thresh: %u", pathRod->RetranThresh);
wprintf(L"\nSnd Dup Ack Episodes: %u", pathRod->SndDupAckEpisodes);
wprintf(L"\nSum Bytes Reordered: %u", pathRod->SumBytesReordered);
wprintf(L"\nNon Recov Da: %u", pathRod->NonRecovDa);
wprintf(L"\nNon Recov Da Episodes: %u", pathRod->NonRecovDaEpisodes);
wprintf(L"\nAck After Fr: %u", pathRod->AckAfterFr);
wprintf(L"\nDsack Dups: %u", pathRod->DsackDups);
wprintf(L"\nSample Rtt: 0x%x (%u)", pathRod->SampleRtt,
pathRod->SampleRtt);
wprintf(L"\nSmoothed Rtt: %u", pathRod->SmoothedRtt);
wprintf(L"\nRtt Var: %u", pathRod->RttVar);
wprintf(L"\nMax Rtt: %u", pathRod->MaxRtt);
wprintf(L"\nMin Rtt: 0x%x (%u)", pathRod->MinRtt,
pathRod->MinRtt);
wprintf(L"\nSum Rtt: %u", pathRod->SumRtt);
wprintf(L"\nCount Rtt: %u", pathRod->CountRtt);
wprintf(L"\nCur Rto: %u", pathRod->CurRto);
wprintf(L"\nMax Rto: %u", pathRod->MaxRto);
wprintf(L"\nMin Rto: %u", pathRod->MinRto);
wprintf(L"\nCur Mss: %u", pathRod->CurMss);
wprintf(L"\nMax Mss: %u", pathRod->MaxMss);
wprintf(L"\nMin Mss: %u", pathRod->MinMss);
wprintf(L"\nSpurious Rto: %u", pathRod->SpuriousRtoDetections);
break;
case TcpConnectionEstatsSendBuff:
sndBuffRod = (PTCP_ESTATS_SEND_BUFF_ROD_v0)rod;
wprintf(L"\n\nSend Buff");
wprintf(L"\nCur Retx Queue: %u", sndBuffRod->CurRetxQueue);
wprintf(L"\nMax Retx Queue: %u", sndBuffRod->MaxRetxQueue);
wprintf(L"\nCur App W Queue: %u", sndBuffRod->CurAppWQueue);
wprintf(L"\nMax App W Queue: %u", sndBuffRod->MaxAppWQueue);
break;
case TcpConnectionEstatsRec:
recRod = (PTCP_ESTATS_REC_ROD_v0)rod;
wprintf(L"\n\nRec");
wprintf(L"\nCur Rwin Sent: 0x%x (%u)", recRod->CurRwinSent,
recRod->CurRwinSent);
wprintf(L"\nMax Rwin Sent: 0x%x (%u)", recRod->MaxRwinSent,
recRod->MaxRwinSent);
wprintf(L"\nMin Rwin Sent: 0x%x (%u)", recRod->MinRwinSent,
recRod->MinRwinSent);
wprintf(L"\nLim Rwin: 0x%x (%u)", recRod->LimRwin,
recRod->LimRwin);
wprintf(L"\nDup Acks: %u", recRod->DupAckEpisodes);
wprintf(L"\nDup Acks Out: %u", recRod->DupAcksOut);
wprintf(L"\nCe Rcvd: %u", recRod->CeRcvd);
wprintf(L"\nEcn Send: %u", recRod->EcnSent);
wprintf(L"\nEcn Nonces Rcvd: %u", recRod->EcnNoncesRcvd);
wprintf(L"\nCur Reasm Queue: %u", recRod->CurReasmQueue);
wprintf(L"\nMax Reasm Queue: %u", recRod->MaxReasmQueue);
wprintf(L"\nCur App R Queue: %u", recRod->CurAppRQueue);
wprintf(L"\nMax App R Queue: %u", recRod->MaxAppRQueue);
wprintf(L"\nWin Scale Sent: 0x%.2x", recRod->WinScaleSent);
break;
case TcpConnectionEstatsObsRec:
obsRecRod = (PTCP_ESTATS_OBS_REC_ROD_v0)rod;
wprintf(L"\n\nObs Rec");
wprintf(L"\nCur Rwin Rcvd: 0x%x (%u)", obsRecRod->CurRwinRcvd,
obsRecRod->CurRwinRcvd);
wprintf(L"\nMax Rwin Rcvd: 0x%x (%u)", obsRecRod->MaxRwinRcvd,
obsRecRod->MaxRwinRcvd);
wprintf(L"\nMin Rwin Rcvd: 0x%x (%u)", obsRecRod->MinRwinRcvd,
obsRecRod->MinRwinRcvd);
wprintf(L"\nWin Scale Rcvd: 0x%x (%u)", obsRecRod->WinScaleRcvd,
obsRecRod->WinScaleRcvd);
break;
case TcpConnectionEstatsBandwidth:
bandwidthRod = (PTCP_ESTATS_BANDWIDTH_ROD_v0)rod;
wprintf(L"\n\nBandwidth");
wprintf(L"\nOutbound Bandwidth: %lu",
bandwidthRod->OutboundBandwidth);
wprintf(L"\nInbound Bandwidth: %lu", bandwidthRod->InboundBandwidth);
wprintf(L"\nOutbound Instability: %lu",
bandwidthRod->OutboundInstability);
wprintf(L"\nInbound Instability: %lu",
bandwidthRod->InboundInstability);
wprintf(L"\nOutbound Bandwidth Peaked: %s",
bandwidthRod->OutboundBandwidthPeaked ? L"Yes" : L"No");
wprintf(L"\nInbound Bandwidth Peaked: %s",
bandwidthRod->InboundBandwidthPeaked ? L"Yes" : L"No");
break;
case TcpConnectionEstatsFineRtt:
fineRttRod = (PTCP_ESTATS_FINE_RTT_ROD_v0)rod;
wprintf(L"\n\nFine RTT");
wprintf(L"\nRtt Var: %u", fineRttRod->RttVar);
wprintf(L"\nMax Rtt: %u", fineRttRod->MaxRtt);
wprintf(L"\nMin Rtt: 0x%x (%u) ", fineRttRod->MinRtt,
fineRttRod->MinRtt);
wprintf(L"\nSum Rtt: %u", fineRttRod->SumRtt);
break;
default:
wprintf(L"\nCannot get type %d", type);
break;
}
}
free(ros);
free(rod);
}
要求
| 最低受支持的客户端 | Windows Vista [仅限桌面应用] |
| 最低受支持的服务器 | Windows Server 2008 [仅限桌面应用] |
| 目标平台 | Windows |
| 标头 | iphlpapi.h |
| Library | Iphlpapi.lib |
| DLL | Iphlpapi.dll |
另请参阅
反馈
即将发布：在整个 2024 年，我们将逐步淘汰作为内容反馈机制的“GitHub 问题”，并将其取代为新的反馈系统。 有关详细信息，请参阅：https://aka.ms/ContentUserFeedback。
提交和查看相关反馈