GetPerTcpConnectionEStats function (Windows)

GetPerTcpConnectionEStats function

GetPerTcpConnectionEStats function

Applies to: desktop apps only

The GetPerTcpConnectionEStats function retrieves extended statistics for an IPv4 TCP connection.

Syntax

ULONG WINAPI GetPerTcpConnectionEStats(
  PMIB_TCPROW 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

A pointer to a MIB_TCPROW structure for an IPv4 TCP connection.

EstatsType

The type of extended statistics for TCP requested. This parameter determines the data and format of information that is returned in the Rw, Rod, and Ros parameters if the call is successful.

This parameter can be one of the values from the TCP_ESTATS_TYPE enumeration type defined in the Tcpestats.h header file.

Value	Meaning
TcpConnectionEstatsSynOpts	This value requests SYN exchange information for a TCP connection. Only read-only static information is available for this enumeration value. If the Ros parameter was not NULL and the function succeeds, the buffer pointed to by the Ros parameter should contain a TCP_ESTATS_SYN_OPTS_ROS_v0 structure.
TcpConnectionEstatsData	This value requests extended data transfer information for a TCP connection. Only read-only dynamic information and read/write information are available for this enumeration value. If the Rw parameter was not NULL and the function succeeds, the buffer pointed to by the Rw parameter should contain a TCP_ESTATS_DATA_RW_v0 structure. If extended data transfer information was enabled for this TCP connection, the Rod parameter was not NULL, and the function succeeds, the buffer pointed to by the Rod parameter should contain a TCP_ESTATS_DATA_ROD_v0 structure.
TcpConnectionEstatsSndCong	This value requests sender congestion for a TCP connection. All three types of information (read-only static, read-only dynamic, and read/write information) are available for this enumeration value. If the Rw parameter was not NULL and the function succeeds, the buffer pointed to by the Rw parameter should contain a TCP_ESTATS_SND_CONG_RW_v0 structure. If the Ros parameter was not NULL and the function succeeds, the buffer pointed to by the Ros parameter should contain a TCP_ESTATS_SND_CONG_ROS_v0 structure. If sender congestion information was enabled for this TCP connection, the Rod parameter was not NULL, and the function succeeds, the buffer pointed to by the Rod parameter should contain a TCP_ESTATS_SND_CONG_ROD_v0 structure.
TcpConnectionEstatsPath	This value requests extended path measurement information for a TCP connection. Only read-only dynamic information and read/write information are available for this enumeration value. If the Rw parameter was not NULL and the function succeeds, the buffer pointed to by the Rw parameter should contain a TCP_ESTATS_PATH_RW_v0 structure. If extended path measurement information was enabled for this TCP connection, the Rod parameter was not NULL, and the function succeeds, the buffer pointed to by the Rod parameter should contain a TCP_ESTATS_PATH_ROD_v0 structure.
TcpConnectionEstatsSendBuff	This value requests extended output-queuing information for a TCP connection. Only read-only dynamic information and read/write information are available for this enumeration value. If the Rw parameter was not NULL and the function succeeds, the buffer pointed to by the Rw parameter should contain a TCP_ESTATS_SEND_BUFF_RW_v0 structure. If extended output-queuing information was enabled for this TCP connection, the Rod parameter was not NULL, and the function succeeds, the buffer pointed to by the Rod parameter should contain a TCP_ESTATS_SEND_BUFF_ROD_v0 structure.
TcpConnectionEstatsRec	This value requests extended local-receiver information for a TCP connection. Only read-only dynamic information and read/write information are available for this enumeration value. If the Rw parameter was not NULL and the function succeeds, the buffer pointed to by the Rw parameter should contain a TCP_ESTATS_REC_RW_v0 structure. If extended local-receiver information was enabled for this TCP connection, the Rod parameter was not NULL, and the function succeeds, the buffer pointed to by the Rod parameter should contain a TCP_ESTATS_REC_ROD_v0 structure.
TcpConnectionEstatsObsRec	This value requests extended remote-receiver information for a TCP connection. Only read-only dynamic information and read/write information are available for this enumeration value. If the Rw parameter was not NULL and the function succeeds, the buffer pointed to by the Rw parameter should contain a TCP_ESTATS_OBS_REC_RW_v0 structure. If extended remote-receiver information was enabled for this TCP connection, the Rod parameter was not NULL, and the function succeeds, the buffer pointed to by the Rod parameter should contain a TCP_ESTATS_OBS_REC_ROD_v0 structure.
TcpConnectionEstatsBandwidth	This value requests bandwidth estimation statistics for a TCP connection on bandwidth. Only read-only dynamic information and read/write information are available for this enumeration value. If the Rw parameter was not NULL and the function succeeds, the buffer pointed to by the Rw parameter should contain a TCP_ESTATS_BANDWIDTH_RW_v0 structure. If bandwidth estimation statistics was enabled for this TCP connection, the Rod parameter was not NULL, and the function succeeds, the buffer pointed to by the Rod parameter should contain a TCP_ESTATS_BANDWIDTH_ROD_v0 structure.
TcpConnectionEstatsFineRtt	This value requests fine-grained round-trip time (RTT) estimation statistics for a TCP connection. Only read-only dynamic information and read/write information are available for this enumeration value. If the Rw parameter was not NULL and the function succeeds, the buffer pointed to by the Rw parameter should contain a TCP_ESTATS_FINE_RTT_RW_v0 structure. If fine-grained RTT estimation statistics was enabled for this TCP connection, the Rod parameter was not NULL, and the function succeeds, the buffer pointed to by the Rod parameter should contain a TCP_ESTATS_FINE_RTT_ROD_v0 structure.

Rw [out]

A pointer to a buffer to receive the read/write information. This parameter may be a NULL pointer if an application does not want to retrieve read/write information for the TCP connection.

RwVersion

The version of the read/write information requested. The current supported value is a version of zero.

RwSize

The size, in bytes, of the buffer pointed to by Rw parameter.

Ros [out]

A pointer to a buffer to receive read-only static information. This parameter may be a NULL pointer if an application does not want to retrieve read-only static information for the TCP connection.

RosVersion

The version of the read-only static information requested. The current supported value is a version of zero.

RosSize

The size, in bytes, of the buffer pointed to by the Ros parameter.

Rod [out]

A pointer to a buffer to receive read-only dynamic information. This parameter may be a NULL pointer if an application does not want to retrieve read-only dynamic information for the TCP connection.

RodVersion

The version of the read-only dynamic information requested. The current supported value is a version of zero.

RodSize

The size, in bytes, of the buffer pointed to by the Rod parameter.

Return value

If the function succeeds, the return value is NO_ERROR.

If the function fails, the return value is one of the following error codes.

Return code	Description
ERROR_INSUFFICIENT_BUFFER	A buffer passed to a function is too small. This error is returned if the buffer pointed to by the Rw, Ros, or Rod parameters is not large enough to receive the data. This error also returned if one of the given buffers pointed to by the Rw, Ros, or Rod parameters is NULL, but a length was specified in the associated RwSize, RosSize, or RodSize. This error value is returned on Windows Vista and Windows Server 2008.
ERROR_INVALID_PARAMETER	The parameter is incorrect. This error is returned if the Row parameter is a NULL pointer.
ERROR_INVALID_USER_BUFFER	The supplied user buffer is not valid for the requested operation. This error is returned if one of the given buffers pointed to by the Rw, Ros, or Rod parameters is NULL, but a length was specified in the associated RwSize, RosSize, or RodSize. As a result, this error is returned if any of the following conditions are met: The Row parameter is a NULL pointer and the RwSize parameter is nonzero. The Ros parameter is a NULL pointer and the RosSize parameter is nonzero. The Rod parameter is a NULL pointer and the RodSize parameter is nonzero. This error value is returned on Windows 7 and Windows Server 2008 R2.
ERROR_NOT_FOUND	This requested entry was not found. This error is returned if the TCP connection specified in the Row parameter could not be found.
ERROR_NOT_SUPPORTED	The request is not supported. This error is returned if the RwVersion, RosVersion, or RodVersion parameter is not set to zero.
Other	Use FormatMessage to obtain the message string for the returned error.

Remarks

The GetPerTcpConnectionEStats function is defined on Windows Vista and later.

The GetPerTcpConnectionEStats function is designed to use TCP to diagnose performance problems in both the network and the application. If a network based application is performing poorly, TCP can determine if the bottleneck is in the sender, the receiver or the network itself. If the bottleneck is in the network, TCP can provide specific information about its nature.

The GetPerTcpConnectionEStats function retrieves extended statistics for the IPv4 TCP connection passed in the Row parameter. The type of extended statistics that is retrieved is specified in the EstatsType parameter. Extended statistics on this TCP connection must have previously been enabled by calls to the SetPerTcpConnectionEStats function for all TCP_ESTATS_TYPE values except when TcpConnectionEstatsSynOpts is passed in the EstatsType parameter.

The GetTcpTable function is used to retrieve the IPv4 TCP connection table on the local computer. This function returns a MIB_TCPTABLE structure that contain an array of MIB_TCPROW entries. The Row parameter passed to the GetPerTcpConnectionEStats function must be an entry for an existing IPv4 TCP connection.

The only version of TCP connection statistics currently supported is version zero. So the RwVersion, RosVersion, and RodVersion parameters passed to GetPerTcpConnectionEStats should be set to 0.

For information on extended TCP statistics on an IPv6 connection, see the GetPerTcp6ConnectionEStats and SetPerTcp6ConnectionEStats functions.

The SetPerTcpConnectionEStats function can only be called by a user logged on as a member of the Administrators group. If SetPerTcpConnectionEStats is called by a user that is not a member of the Administrators group, the function call will fail and ERROR_ACCESS_DENIED is returned. This function can also fail because of user account control (UAC) on Windows Vista and later. If an application that contains this function is executed by a user logged on as a member of the Administrators group other than the built-in Administrator, this call will fail unless the application has been marked in the manifest file with a requestedExecutionLevel set to requireAdministrator. If the application lacks this manifest file, a user logged on as a member of the Administrators group other than the built-in Administrator must then be executing the application in an enhanced shell as the built-in Administrator (RunAs administrator) for this function to succeed.

An application that uses the GetPerTcpConnectionEStats function to retrieve extended statistics for an IPv4 TCP connection must check that the previous call to the SetPerTcpConnectionEStats function to enabled extended statistics returned with success. If the SetPerTcpConnectionEStats function to enable extended statistics failed, subsequent calls to the GetPerTcpConnectionEStats will still return numbers in the returned structures. However the returned numbers are meaningless random data and don't represent extended TCP statistics. This behavior can be observed by running the example below as both an administrator and a normal user.

Examples

The following example retrieves the TCP extended statistics for an IPv4 and IPv6 TCP connection and prints values from the returned data.

C++

// 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
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;
    wchar_t *loopback;
    loopback = v6 ? L"::1" : L"127.0.0.1";
    int aiFamily = v6 ? AF_INET6 : AF_INET;

    *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;
    int nameLen = sizeof (SOCKADDR_STORAGE);
    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);
}

//
// 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
    }

    if (v6) {
        winStatus = GetPerTcp6ConnectionEStats((PMIB_TCP6ROW) row,
                                               type,
                                               NULL, 0, 0,
                                               ros, 0, rosSize,
                                               rod, 0, rodSize);
    } else {
        winStatus = GetPerTcpConnectionEStats((PMIB_TCPROW) row,
                                              type,
                                              NULL, 0, 0,
                                              ros, 0, rosSize, rod, 0, rodSize);
    }
    
    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);
}

Requirements