windows-xp/Source/XPSP1/NT/net/tcpip/driver/tcp/info.c

/********************************************************************/
/**                     Microsoft LAN Manager                      **/
/**               Copyright(c) Microsoft Corp., 1990-1997          **/
/********************************************************************/
/* :ts=4 */

//** INFO.C - TDI Query/SetInformation routines.
//
//  This file contains the code for dealing with TDI Query/Set information
//  calls.
//

#include "precomp.h"
#include "tdint.h"
#include "addr.h"
#include "tcp.h"
#include "tcb.h"
#include "tcpconn.h"
#include "tlcommon.h"
#include "info.h"
#include "tcpcfg.h"
#include "udp.h"
#include "tcpsend.h"

TCPInternalStats TStats;
TCPInternalPerCpuStats TPerCpuStats[TCPS_MAX_PROCESSOR_BUCKETS];
UDPStats UStats;

extern uint MaxRcvWin;
extern uint TcpHostOpts;
extern uint NumTcbTablePartitions;
extern ulong DisableUserTOSSetting;
extern uint StartTime;

#define MY_SERVICE_FLAGS    (TDI_SERVICE_CONNECTION_MODE    | \
                            TDI_SERVICE_ORDERLY_RELEASE     | \
                            TDI_SERVICE_CONNECTIONLESS_MODE | \
                            TDI_SERVICE_ERROR_FREE_DELIVERY | \
                            TDI_SERVICE_BROADCAST_SUPPORTED | \
                            TDI_SERVICE_DELAYED_ACCEPTANCE  | \
                            TDI_SERVICE_EXPEDITED_DATA      | \
                            TDI_SERVICE_DGRAM_CONNECTION    | \
                            TDI_SERVICE_FORCE_ACCESS_CHECK  | \
                            TDI_SERVICE_SEND_AND_DISCONNECT | \
                            TDI_SERVICE_ACCEPT_LOCAL_ADDR | \
                            TDI_SERVICE_NO_ZERO_LENGTH)

struct ReadTableStruct {
    uint(*rts_validate) (void *Context, uint * Valid);
    uint(*rts_readnext) (void *Context, void *OutBuf);
};

struct ReadTableStruct ReadAOTable = {ValidateAOContext, ReadNextAO};
struct ReadTableStruct ReadTCBTable = {ValidateTCBContext, ReadNextTCB};

extern CTELock *pTCBTableLock;
extern CTELock *pTWTCBTableLock;
extern IPInfo LocalNetInfo;

struct TDIEntityID *EntityList;
uint EntityCount;
CTELock EntityLock;

//* TdiQueryInformation - Query Information handler.
//
//  The TDI QueryInformation routine. Called when the client wants to
//  query information on a connection, the provider as a whole, or to
//  get statistics.
//
//  Input:  Request             - The request structure for this command.
//          QueryType           - The type of query to be performed.
//          Buffer              - Buffer to place data into.
//          BufferSize          - Pointer to size in bytes of buffer. On return,
//                                  filled in with bytes copied.
//          IsConn              - Valid only for TDI_QUERY_ADDRESS_INFO. TRUE
//                                  if we are querying the address info on
//                                  a connection.
//
//  Returns: Status of attempt to query information.
//
TDI_STATUS
TdiQueryInformation(PTDI_REQUEST Request, uint QueryType, PNDIS_BUFFER Buffer,
                    uint * BufferSize, uint IsConn)
{
    union {
        TDI_CONNECTION_INFO ConnInfo;
        TDI_ADDRESS_INFO AddrInfo;
        TDI_PROVIDER_INFO ProviderInfo;
        TDI_PROVIDER_STATISTICS ProviderStats;
    } InfoBuf;

    uint InfoSize;
    CTELockHandle ConnTableHandle, TCBHandle, AddrHandle, AOHandle;
    TCPConn *Conn;
    TCB *InfoTCB;
    AddrObj *InfoAO;
    void *InfoPtr = NULL;
    uint Offset;
    uint Size;
    uint BytesCopied;

    switch (QueryType) {

    case TDI_QUERY_BROADCAST_ADDRESS:
        return TDI_INVALID_QUERY;
        break;

    case TDI_QUERY_PROVIDER_INFO:
        InfoBuf.ProviderInfo.Version = 0x100;
        InfoBuf.ProviderInfo.MaxSendSize = 0xffffffff;
        InfoBuf.ProviderInfo.MaxConnectionUserData = 0;
        InfoBuf.ProviderInfo.MaxDatagramSize =
            0xffff - (sizeof(IPHeader) + sizeof(UDPHeader));
        InfoBuf.ProviderInfo.ServiceFlags = MY_SERVICE_FLAGS;
        InfoBuf.ProviderInfo.MinimumLookaheadData = 1;
        InfoBuf.ProviderInfo.MaximumLookaheadData = 0xffff;
        InfoBuf.ProviderInfo.NumberOfResources = 0;
        InfoBuf.ProviderInfo.StartTime.LowPart = StartTime;
        InfoBuf.ProviderInfo.StartTime.HighPart = 0;
        InfoSize = sizeof(TDI_PROVIDER_INFO);
        InfoPtr = &InfoBuf.ProviderInfo;
        break;

    case TDI_QUERY_ADDRESS_INFO:
        InfoSize = sizeof(TDI_ADDRESS_INFO) - sizeof(TRANSPORT_ADDRESS) +
            TCP_TA_SIZE;
        NdisZeroMemory(&InfoBuf.AddrInfo, TCP_TA_SIZE);
        InfoBuf.AddrInfo.ActivityCount = 1;        // Since noone knows what
        // this means, we'll set
        // it to one.

        if (IsConn) {

            CTEGetLock(&AddrObjTableLock.Lock, &AddrHandle);
            //CTEGetLock(&ConnTableLock, &ConnTableHandle);
            Conn = GetConnFromConnID(PtrToUlong(Request->Handle.ConnectionContext), &ConnTableHandle);

            if (Conn != NULL) {
                CTEStructAssert(Conn, tc);

                InfoTCB = Conn->tc_tcb;
                // If we have a TCB we'll
                // return information about that TCB. Otherwise we'll return
                // info about the address object.
                if (InfoTCB != NULL) {
                    CTEStructAssert(InfoTCB, tcb);
                    CTEGetLock(&InfoTCB->tcb_lock, &TCBHandle);
                    CTEFreeLock(&(Conn->tc_ConnBlock->cb_lock), TCBHandle);
                    CTEFreeLock(&AddrObjTableLock.Lock, ConnTableHandle);
                    BuildTDIAddress((uchar *) & InfoBuf.AddrInfo.Address,
                                    InfoTCB->tcb_saddr, InfoTCB->tcb_sport);
                    CTEFreeLock(&InfoTCB->tcb_lock, AddrHandle);
                    InfoPtr = &InfoBuf.AddrInfo;
                    break;
                } else {
                    // No TCB, return info on the AddrObj.
                    InfoAO = Conn->tc_ao;
                    if (InfoAO != NULL) {
                        // We have an AddrObj.
                        CTEStructAssert(InfoAO, ao);
                        CTEGetLock(&InfoAO->ao_lock, &AOHandle);
                        BuildTDIAddress((uchar *) & InfoBuf.AddrInfo.Address,
                                        InfoAO->ao_addr, InfoAO->ao_port);
                        CTEFreeLock(&InfoAO->ao_lock, AOHandle);
                        CTEFreeLock(&(Conn->tc_ConnBlock->cb_lock), ConnTableHandle);

                        CTEFreeLock(&AddrObjTableLock.Lock, AddrHandle);
                        InfoPtr = &InfoBuf.AddrInfo;
                        break;
                    } else
                        CTEFreeLock(&(Conn->tc_ConnBlock->cb_lock), ConnTableHandle);
                }

            }
            // Fall through to here when we can't find the connection, or
            // the connection isn't associated.
            //CTEFreeLock(&ConnTableLock, ConnTableHandle);
            CTEFreeLock(&AddrObjTableLock.Lock, AddrHandle);
            return TDI_INVALID_CONNECTION;
            break;

        } else {
            // Asking for information on an addr. object.
            InfoAO = Request->Handle.AddressHandle;
            if (InfoAO == NULL)
                return TDI_ADDR_INVALID;

            CTEStructAssert(InfoAO, ao);

            CTEGetLock(&InfoAO->ao_lock, &AOHandle);

            if (!AO_VALID(InfoAO)) {
                CTEFreeLock(&InfoAO->ao_lock, AOHandle);
                return TDI_ADDR_INVALID;

            } else if (AO_CONNUDP(InfoAO) &&
                     IP_ADDR_EQUAL(InfoAO->ao_addr, NULL_IP_ADDR) &&
                     InfoAO->ao_rce &&
                     (InfoAO->ao_rce->rce_flags & RCE_VALID)) {
                BuildTDIAddress((uchar *) & InfoBuf.AddrInfo.Address,
                                InfoAO->ao_rcesrc, InfoAO->ao_port);
                CTEFreeLock(&InfoAO->ao_lock, AOHandle);
                InfoPtr = &InfoBuf.AddrInfo;
                break;
            }
            BuildTDIAddress((uchar *) & InfoBuf.AddrInfo.Address,
                            InfoAO->ao_addr, InfoAO->ao_port);

            CTEFreeLock(&InfoAO->ao_lock, AOHandle);
            InfoPtr = &InfoBuf.AddrInfo;
            break;
        }

        break;

    case TDI_QUERY_CONNECTION_INFO:

        InfoSize = sizeof(TDI_CONNECTION_INFO);
        //CTEGetLock(&ConnTableLock, &ConnTableHandle);
        Conn = GetConnFromConnID(PtrToUlong(Request->Handle.ConnectionContext), &ConnTableHandle);

        if (Conn != NULL) {
            CTEStructAssert(Conn, tc);

            InfoTCB = Conn->tc_tcb;
            // If we have a TCB we'll return the information. Otherwise
            // we'll error out.
            if (InfoTCB != NULL) {

                ulong TotalTime;
                ulong BPS, PathBPS;
                IP_STATUS IPStatus;
                CTEULargeInt TempULargeInt;

                CTEStructAssert(InfoTCB, tcb);
                CTEGetLock(&InfoTCB->tcb_lock, &TCBHandle);
                CTEFreeLock(&(Conn->tc_ConnBlock->cb_lock), TCBHandle);
                NdisZeroMemory(&InfoBuf.ConnInfo, sizeof(TDI_CONNECTION_INFO));
                InfoBuf.ConnInfo.State = (ulong) InfoTCB->tcb_state;
                IPStatus = (*LocalNetInfo.ipi_getpinfo) (InfoTCB->tcb_daddr,
                                                         InfoTCB->tcb_saddr, NULL, &PathBPS, InfoTCB->tcb_rce);

                if (IPStatus != IP_SUCCESS) {
                    InfoBuf.ConnInfo.Throughput.LowPart = 0xFFFFFFFF;
                    InfoBuf.ConnInfo.Throughput.HighPart = 0xFFFFFFFF;
                } else {
                    InfoBuf.ConnInfo.Throughput.HighPart = 0;
                    TotalTime = InfoTCB->tcb_totaltime /
                        (1000 / MS_PER_TICK);
                    if (TotalTime != 0 && (TotalTime > InfoTCB->tcb_bcounthi)) {
                        TempULargeInt.LowPart = InfoTCB->tcb_bcountlow;
                        TempULargeInt.HighPart = InfoTCB->tcb_bcounthi;

                        BPS = CTEEnlargedUnsignedDivide(TempULargeInt,
                                                        TotalTime, NULL);
                        InfoBuf.ConnInfo.Throughput.LowPart =
                            MIN(BPS, PathBPS);
                    } else
                        InfoBuf.ConnInfo.Throughput.LowPart = PathBPS;
                }

                // To figure the delay we use the rexmit timeout. Our
                // rexmit timeout is roughly the round trip time plus
                // some slop, so we use half of that as the one way delay.
                InfoBuf.ConnInfo.Delay.LowPart =
                    (REXMIT_TO(InfoTCB) * MS_PER_TICK) / 2;
                InfoBuf.ConnInfo.Delay.HighPart = 0;
                //
                // Convert milliseconds to 100ns and negate for relative
                // time.
                //
                InfoBuf.ConnInfo.Delay =
                    RtlExtendedIntegerMultiply(
                                               InfoBuf.ConnInfo.Delay,
                                               10000
                                               );

                ASSERT(InfoBuf.ConnInfo.Delay.HighPart == 0);

                InfoBuf.ConnInfo.Delay.QuadPart =
                    -InfoBuf.ConnInfo.Delay.QuadPart;

                CTEFreeLock(&InfoTCB->tcb_lock, ConnTableHandle);
                InfoPtr = &InfoBuf.ConnInfo;
                break;
            }
            CTEFreeLock(&(Conn->tc_ConnBlock->cb_lock), ConnTableHandle);

        }
        // Come through here if we can't find the connection or it has
        // no TCB.
        //CTEFreeLock(&ConnTableLock, ConnTableHandle);
        return TDI_INVALID_CONNECTION;
        break;

    case TDI_QUERY_PROVIDER_STATISTICS:
        NdisZeroMemory(&InfoBuf.ProviderStats, sizeof(TDI_PROVIDER_STATISTICS));
        InfoBuf.ProviderStats.Version = 0x100;
        InfoSize = sizeof(TDI_PROVIDER_STATISTICS);
        InfoPtr = &InfoBuf.ProviderStats;
        break;
    default:
        return TDI_INVALID_QUERY;
        break;
    }

    // When we get here, we've got the pointers set up and the information
    // filled in.

    ASSERT(InfoPtr != NULL);
    Offset = 0;
    Size = *BufferSize;
    (void)CopyFlatToNdis(Buffer, InfoPtr, MIN(InfoSize, Size), &Offset,
                         &BytesCopied);
    if (Size < InfoSize)
        return TDI_BUFFER_OVERFLOW;
    else {
        *BufferSize = InfoSize;
        return TDI_SUCCESS;
    }
}

//* TdiSetInformation - Set Information handler.
//
//  The TDI SetInformation routine. Currently we don't allow anything to be
//  set.
//
//  Input:  Request             - The request structure for this command.
//          SetType             - The type of set to be performed.
//          Buffer              - Buffer to set from.
//          BufferSize          - Size in bytes of buffer.
//          IsConn              - Valid only for TDI_QUERY_ADDRESS_INFO. TRUE
//                                  if we are setting the address info on
//                                  a connection.
//
//  Returns: Status of attempt to set information.
//
TDI_STATUS
TdiSetInformation(PTDI_REQUEST Request, uint SetType, PNDIS_BUFFER Buffer,
                  uint BufferSize, uint IsConn)
{
    return TDI_INVALID_REQUEST;
}

//* TdiAction - Action handler.
//
//  The TDI Action routine. Currently we don't support any actions.
//
//  Input:  Request             - The request structure for this command.
//          ActionType          - The type of action to be performed.
//          Buffer              - Buffer of action info.
//          BufferSize          - Size in bytes of buffer.
//
//  Returns: Status of attempt to perform action.
//
TDI_STATUS
TdiAction(PTDI_REQUEST Request, uint ActionType, PNDIS_BUFFER Buffer,
          uint BufferSize)
{
    return TDI_INVALID_REQUEST;
}

// We are looking only for missing TCPConnTableEntry ies,
// ie. listen.

int
CopyAO_TCPConn(const AddrObj *AO, uint InfoSize, TCPConnTableEntryEx *Buffer)
{
    if (AO == NULL)
        return 0;

    ASSERT(InfoSize == sizeof(TCPConnTableEntry) ||
           InfoSize == sizeof(TCPConnTableEntryEx));

    if ((!AO->ao_listencnt) && (AO->ao_prot == PROTOCOL_TCP)) {
        Buffer->tcte_basic.tct_state = TCP_CONN_LISTEN;

        // else if .. other cases can be added here ...

    } else {
        return 0;
    }

    Buffer->tcte_basic.tct_localaddr = AO->ao_addr;
    Buffer->tcte_basic.tct_localport = AO->ao_port;
    Buffer->tcte_basic.tct_remoteaddr = 0;
    Buffer->tcte_basic.tct_remoteport = (ULONG) ((ULONG_PTR) AO & 0x0000ffff);

    if (InfoSize > sizeof(TCPConnTableEntry)) {
        ((TCPConnTableEntryEx*)Buffer)->tcte_owningpid = AO->ao_owningpid;
    }

    return 1;
}

//* TdiQueryInfoEx - Extended TDI query information.
//
//  This is the new TDI query information handler. We take in a TDIObjectID
//  structure, a buffer and length, and some context information, and return
//  the requested information if possible.
//
//  Input:  Request         - The request structure for this command.
//          ID              - The object ID
//          Buffer          - Pointer to buffer to be filled in.
//          Size            - Pointer to size in bytes of Buffer. On exit,
//                              filled in with bytes written.
//          Context         - Pointer to context buffer.
//
//  Returns: Status of attempt to get information.
//

TDI_STATUS
TdiQueryInformationEx(PTDI_REQUEST Request, TDIObjectID * ID,
                      PNDIS_BUFFER Buffer, uint * Size, void *Context)
{
    uint BufferSize = *Size;
    uint InfoSize;
    void *InfoPtr;
    uint Fixed;
    CTELockHandle Handle, DpcHandle, TableHandle;
    CTELock *AOLockPtr = NULL;
    uint Offset = 0;
    uchar InfoBuffer[sizeof(TCPConnTableEntryEx)];
    uint BytesRead;
    uint Valid;
    uint Entity;
    uint BytesCopied;
    TCPStats TCPStatsListen;

    CTELockHandle EntityHandle, TWHandle, TWDpcHandle;
    CTELock *TWLockPtr;
    BOOLEAN TWTABLELOCK = FALSE;
    BOOLEAN TABLELOCK = FALSE;

    int lcount;
    AddrObj *pAO;
    TCPConnTableEntryEx tcp_ce;
    uint Index, i;
    int InfoTcpConn = 0;        // true if tcp conn info needed.

    // First check to see if he's querying for list of entities.
    Entity = ID->toi_entity.tei_entity;
    if (Entity == GENERIC_ENTITY) {
        *Size = 0;

        if (ID->toi_class != INFO_CLASS_GENERIC ||
            ID->toi_type != INFO_TYPE_PROVIDER ||
            ID->toi_id != ENTITY_LIST_ID) {
            return TDI_INVALID_PARAMETER;
        }

        CTEGetLock(&EntityLock, &EntityHandle);

        // Make sure we have room for it the list in the buffer.
        InfoSize = EntityCount * sizeof(TDIEntityID);

        if (BufferSize < InfoSize) {
            // Not enough room.
            CTEFreeLock(&EntityLock, EntityHandle);
            return TDI_BUFFER_TOO_SMALL;
        }
        *Size = InfoSize;

        // Copy it in, free our temp. buffer, and return success.
        (void)CopyFlatToNdis(Buffer, (uchar *) EntityList, InfoSize, &Offset,
                             &BytesCopied);
        CTEFreeLock(&EntityLock, EntityHandle);
        return TDI_SUCCESS;
    }
    //* Check the level. If it can't be for us, pass it down.
    if (Entity != CO_TL_ENTITY && Entity != CL_TL_ENTITY)
    {
        // When we support multiple lower entities at this layer we'll have
        // to figure out which one to dispatch to. For now, just pass it
        // straight down.
        return (*LocalNetInfo.ipi_qinfo) (ID, Buffer, Size, Context);
    }
    if (ID->toi_entity.tei_instance != TL_INSTANCE) {
        // We only support a single instance.
        return TDI_INVALID_REQUEST;
    }
    // Zero returned parameters in case of an error below.
    *Size = 0;

    if (ID->toi_class == INFO_CLASS_GENERIC) {
        // This is a generic request.
        if (ID->toi_type == INFO_TYPE_PROVIDER && ID->toi_id == ENTITY_TYPE_ID) {
            if (BufferSize >= sizeof(uint)) {
                *(uint *) & InfoBuffer[0] = (Entity == CO_TL_ENTITY) ? CO_TL_TCP
                    : CL_TL_UDP;
                (void)CopyFlatToNdis(Buffer, InfoBuffer, sizeof(uint), &Offset,
                                     &BytesCopied);
                return TDI_SUCCESS;
            } else
                return TDI_BUFFER_TOO_SMALL;
        }
        return TDI_INVALID_PARAMETER;
    }
    if (ID->toi_class == INFO_CLASS_PROTOCOL) {
        // Handle protocol specific class of information. For us, this is
        // the MIB-2 stuff or the minimal stuff we do for oob_inline support.

        if (ID->toi_type == INFO_TYPE_CONNECTION) {
            TCPConn *Conn;
            TCB *QueryTCB;
            TCPSocketAMInfo *AMInfo;
            CTELockHandle TCBHandle;

            if (BufferSize < sizeof(TCPSocketAMInfo) ||
                ID->toi_id != TCP_SOCKET_ATMARK)
                return TDI_INVALID_PARAMETER;

            AMInfo = (TCPSocketAMInfo *) InfoBuffer;
            //CTEGetLock(&ConnTableLock, &Handle);

            Conn = GetConnFromConnID(PtrToUlong(Request->Handle.ConnectionContext), &Handle);

            if (Conn != NULL) {
                CTEStructAssert(Conn, tc);

                QueryTCB = Conn->tc_tcb;
                if (QueryTCB != NULL) {
                    CTEStructAssert(QueryTCB, tcb);
                    CTEGetLock(&QueryTCB->tcb_lock, &TCBHandle);
                    if ((QueryTCB->tcb_flags & (URG_INLINE | URG_VALID)) ==
                        (URG_INLINE | URG_VALID)) {
                        // We're in inline mode, and the urgent data fields are
                        // valid.
                        AMInfo->tsa_size = QueryTCB->tcb_urgend -
                            QueryTCB->tcb_urgstart + 1;
                        // Rcvnext - pendingcnt is the sequence number of the
                        // next byte of data that will be delivered to the
                        // client. Urgend - that value is the offset in the
                        // data stream of the end of urgent data.
                        AMInfo->tsa_offset = QueryTCB->tcb_urgend -
                            (QueryTCB->tcb_rcvnext - QueryTCB->tcb_pendingcnt);
                    } else {
                        AMInfo->tsa_size = 0;
                        AMInfo->tsa_offset = 0;
                    }
                    CTEFreeLock(&QueryTCB->tcb_lock, TCBHandle);
                    CTEFreeLock(&(Conn->tc_ConnBlock->cb_lock), Handle);
                    *Size = sizeof(TCPSocketAMInfo);
                    CopyFlatToNdis(Buffer, InfoBuffer, sizeof(TCPSocketAMInfo),
                                   &Offset, &BytesCopied);
                    return TDI_SUCCESS;
                }
                CTEFreeLock(&(Conn->tc_ConnBlock->cb_lock), Handle);
            }
            return TDI_INVALID_PARAMETER;

        }
        if (ID->toi_type == INFO_TYPE_ADDRESS_OBJECT) {
            // We're getting information on an address object. This is
            // pretty simple.

            return GetAddrOptionsEx(Request, ID->toi_id, BufferSize, Buffer,
                                    Size, Context);

        }
        if (ID->toi_type != INFO_TYPE_PROVIDER)
            return TDI_INVALID_PARAMETER;

        switch (ID->toi_id) {

        case UDP_MIB_STAT_ID:
#if UDP_MIB_STAT_ID != TCP_MIB_STAT_ID
        case TCP_MIB_STAT_ID:
#endif
            Fixed = TRUE;
            if (Entity == CL_TL_ENTITY) {
                InfoSize = sizeof(UDPStats);
                InfoPtr = &UStats;
            } else {
                TCPInternalPerCpuStats SumCpuStats;

                TCPStatsListen.ts_rtoalgorithm = TStats.ts_rtoalgorithm;
                TCPStatsListen.ts_rtomin = TStats.ts_rtomin;
                TCPStatsListen.ts_rtomax = TStats.ts_rtomax;
                TCPStatsListen.ts_maxconn = TStats.ts_maxconn;
                TCPStatsListen.ts_activeopens = TStats.ts_activeopens;
                TCPStatsListen.ts_passiveopens = TStats.ts_passiveopens;
                TCPStatsListen.ts_attemptfails = TStats.ts_attemptfails;
                TCPStatsListen.ts_estabresets = TStats.ts_estabresets;
                TCPStatsListen.ts_currestab = TStats.ts_currestab;
                TCPStatsListen.ts_retranssegs = TStats.ts_retranssegs;
                TCPStatsListen.ts_inerrs = TStats.ts_inerrs;
                TCPStatsListen.ts_outrsts = TStats.ts_outrsts;
                TCPStatsListen.ts_numconns = TStats.ts_numconns;

#if !MILLEN
                TCPSGetTotalCounts(&SumCpuStats);
                TCPStatsListen.ts_insegs = SumCpuStats.tcs_insegs;
                TCPStatsListen.ts_outsegs = SumCpuStats.tcs_outsegs;
#else
                TCPStatsListen.ts_insegs = TStats.ts_insegs;
                TCPStatsListen.ts_outsegs = TStats.ts_outsegs;
#endif

                InfoSize = sizeof(TCPStatsListen);
                InfoPtr = &TCPStatsListen;
                lcount = 0;

                CTEGetLock(&AddrObjTableLock.Lock, &TableHandle);
                for (Index = 0; Index < AddrObjTableSize; Index++) {
                    pAO = AddrObjTable[Index];
                    while (pAO) {
                        lcount += CopyAO_TCPConn(pAO,
                                    sizeof(TCPConnTableEntry),
                                    &tcp_ce);
                        pAO = pAO->ao_next;
                    }
                }
                CTEFreeLock(&AddrObjTableLock.Lock, TableHandle);

                TCPStatsListen.ts_numconns += lcount;

            }
            break;
        case UDP_MIB_TABLE_ID:
#if UDP_MIB_STAT_ID != TCP_MIB_STAT_ID
        case TCP_MIB_TABLE_ID:
#endif
        case UDP_EX_TABLE_ID:
#if UDP_EX_STAT_ID != TCP_EX_STAT_ID
        case TCP_EX_TABLE_ID:
#endif
            Fixed = FALSE;
            if (Entity == CL_TL_ENTITY) {
                InfoSize = (UDP_MIB_TABLE_ID == ID->toi_id)
                            ? sizeof(UDPEntry)
                            : sizeof(UDPEntryEx);
                ((UDPContext*)Context)->uc_infosize = InfoSize;
                InfoPtr = &ReadAOTable;
                CTEGetLock(&AddrObjTableLock.Lock, &Handle);
                AOLockPtr = &AddrObjTableLock.Lock;
            } else {
                InfoSize = (TCP_MIB_TABLE_ID == ID->toi_id)
                            ? sizeof(TCPConnTableEntry)
                            : sizeof(TCPConnTableEntryEx);
                ((TCPConnContext*)Context)->tcc_infosize = InfoSize;
                InfoTcpConn = 1;
                InfoPtr = &ReadTCBTable;
                TABLELOCK = TRUE;

                CTEGetLock(&pTCBTableLock[0], &Handle);
                for (i = 1; i < NumTcbTablePartitions; i++) {
                    CTEGetLock(&pTCBTableLock[i], &DpcHandle);
                }

                CTEGetLock(&pTWTCBTableLock[0], &TWHandle);
                for (i = 1; i < NumTcbTablePartitions; i++) {
                    CTEGetLock(&pTWTCBTableLock[i], &TWDpcHandle);
                }

                TWTABLELOCK = TRUE;

            }
            break;
        default:
            return TDI_INVALID_PARAMETER;
            break;
        }

        if (Fixed) {
            if (BufferSize < InfoSize)
                return TDI_BUFFER_TOO_SMALL;

            *Size = InfoSize;

            (void)CopyFlatToNdis(Buffer, InfoPtr, InfoSize, &Offset,
                                 &BytesCopied);
            return TDI_SUCCESS;
        } else {
            struct ReadTableStruct *RTSPtr;
            uint ReadStatus;

            // Have a variable length (or mult-instance) structure to copy.
            // InfoPtr points to the structure describing the routines to
            // call to read the table.
            // Loop through up to CountWanted times, calling the routine
            // each time.
            BytesRead = 0;

            RTSPtr = InfoPtr;

            ReadStatus = (*(RTSPtr->rts_validate)) (Context, &Valid);

            // If we successfully read something we'll continue. Otherwise
            // we'll bail out.
            if (!Valid) {

                if (TWTABLELOCK) {
                    for (i = NumTcbTablePartitions - 1; i > 0; i--) {
                        CTEFreeLock(&pTWTCBTableLock[i], TWDpcHandle);
                    }
                    CTEFreeLock(&pTWTCBTableLock[0], TWHandle);
                }
                if (TABLELOCK) {
                    for (i = NumTcbTablePartitions - 1; i > 0; i--) {
                        CTEFreeLock(&pTCBTableLock[i], DpcHandle);
                    }
                    CTEFreeLock(&pTCBTableLock[0], Handle);
                }
                if (AOLockPtr)
                    CTEFreeLock(AOLockPtr, Handle);
                return TDI_INVALID_PARAMETER;
            }
            while (ReadStatus) {
                // The invariant here is that there is data in the table to
                // read. We may or may not have room for it. So ReadStatus
                // is TRUE, and BufferSize - BytesRead is the room left
                // in the buffer.
                if ((int)(BufferSize - BytesRead) >= (int)InfoSize) {
                    ReadStatus = (*(RTSPtr->rts_readnext)) (Context,
                                                            InfoBuffer);
                    BytesRead += InfoSize;
                    Buffer = CopyFlatToNdis(Buffer, InfoBuffer, InfoSize,
                                            &Offset, &BytesCopied);
                } else
                    break;

            }

            if (TWTABLELOCK) {
                for (i = NumTcbTablePartitions - 1; i > 0; i--) {
                    CTEFreeLock(&pTWTCBTableLock[i], TWDpcHandle);
                }
                CTEFreeLock(&pTWTCBTableLock[0], TWHandle);
            }
            if (TABLELOCK) {
                for (i = NumTcbTablePartitions - 1; i > 0; i--) {
                    CTEFreeLock(&pTCBTableLock[i], DpcHandle);
                }
                CTEFreeLock(&pTCBTableLock[0], Handle);
            }

            if ((!ReadStatus) && InfoTcpConn) {
                if (!AOLockPtr) {
                    CTEGetLock(&AddrObjTableLock.Lock, &TableHandle);
                    AOLockPtr = &AddrObjTableLock.Lock;
                }
                for (Index = 0; Index < AddrObjTableSize; Index++) {
                    pAO = AddrObjTable[Index];
                    while (pAO) {
                        if (BufferSize < (BytesRead + InfoSize)) {
                            goto no_more_ao;
                        }
                        if (CopyAO_TCPConn(pAO, InfoSize, &tcp_ce)) {
                            ASSERT(BufferSize >= BytesRead);
                            Buffer = CopyFlatToNdis(Buffer, (void *)&tcp_ce,
                                                    InfoSize,
                                                    &Offset, &BytesCopied);
                            BytesRead += InfoSize;
                            ASSERT(BufferSize >= BytesRead);
                        }
                        pAO = pAO->ao_next;
                    }
                }
              no_more_ao:;
            }
            if (AOLockPtr)
                CTEFreeLock(AOLockPtr, Handle);
            *Size = BytesRead;

            return (!ReadStatus ? TDI_SUCCESS : TDI_BUFFER_OVERFLOW);
        }

    }
    if (ID->toi_class == INFO_CLASS_IMPLEMENTATION) {
        // We want to return implementation specific info. For now, error out.
        return TDI_INVALID_PARAMETER;
    }
    return TDI_INVALID_PARAMETER;

}

//* TdiSetInfoEx - Extended TDI set information.
//
//  This is the new TDI set information handler. We take in a TDIObjectID
//  structure, a buffer and length. We set the object specifed by the ID
//  (and possibly by the Request) to the value specified in the buffer.
//
//  Input:  Request         - The request structure for this command.
//          ID              - The object ID
//          Buffer          - Pointer to buffer containing value to set.
//          Size            - Size in bytes of Buffer.
//
//  Returns: Status of attempt to get information.
//
TDI_STATUS
TdiSetInformationEx(PTDI_REQUEST Request, TDIObjectID * ID, void *Buffer,
                    uint Size)
{
    TCPConnTableEntry *TCPEntry;
    CTELockHandle TableHandle, TCBHandle;
    TCB *SetTCB;
    uint Entity;
    TCPConn *Conn;
    TDI_STATUS Status;
    uint index;

    DEBUGMSG(DBG_TRACE && DBG_SETINFO,
        (DTEXT("+TdiSetInformationEx(%x, %x, %x, %d)\n"),
        Request, ID, Buffer, Size));

    //* Check the level. If it can't be for us, pass it down.
    Entity = ID->toi_entity.tei_entity;

    if (Entity != CO_TL_ENTITY && Entity != CL_TL_ENTITY) {
        Status = (*LocalNetInfo.ipi_setinfo) (ID, Buffer, Size);

        DEBUGMSG(Status != TDI_SUCCESS && DBG_ERROR && DBG_SETINFO,
            (DTEXT("TdiSetInformationEx: ipi_setinfo failure %x\n"),
            Status));

        // Someday we'll have to figure out how to dispatch. For now, just pass
        // it down.
        return Status;
    }
    if (ID->toi_entity.tei_instance != TL_INSTANCE)
        return TDI_INVALID_REQUEST;

    if (ID->toi_class == INFO_CLASS_GENERIC) {
        // Fill this in when we have generic class defines.
        return TDI_INVALID_PARAMETER;
    }
    //* Now look at the rest of it.
    if (ID->toi_class == INFO_CLASS_PROTOCOL) {
        // Handle protocol specific class of information. For us, this is
        // the MIB-2 stuff, as well as common sockets options,
        // and in particular the setting of the state of a TCP connection.

        if (ID->toi_type == INFO_TYPE_CONNECTION) {
            TCPSocketOption *Option;
            uint Flag;
            uint Value;

            // A connection type. Get the connection, and then figure out
            // what to do with it.
            Status = TDI_INVALID_PARAMETER;

            if (Size < sizeof(TCPSocketOption))
                return Status;

            //CTEGetLock(&ConnTableLock, &TableHandle);

            Conn = GetConnFromConnID(PtrToUlong(Request->Handle.ConnectionContext), &TableHandle);

            if (Conn != NULL) {
                CTEStructAssert(Conn, tc);

                Status = TDI_SUCCESS;

                Option = (TCPSocketOption *) Buffer;

                if (ID->toi_id == TCP_SOCKET_WINDOW) {
                    // This is a funny option, because it doesn't involve
                    // flags. Handle this specially.

                    // We don't allow anyone to shrink the window, as this
                    // gets too weird from a protocol point of view. Also,
                    // make sure they don't try and set anything too big.


                    if (Option->tso_value > MaxRcvWin)
                        Status = TDI_INVALID_PARAMETER;
                    else if ((Option->tso_value > Conn->tc_window) ||
                             (Conn->tc_tcb == NULL) || (Conn->tc_tcb && Option->tso_value > Conn->tc_tcb->tcb_defaultwin)) {
                        Conn->tc_flags |= CONN_WINSET;
                        Conn->tc_window = Option->tso_value;
                        SetTCB = Conn->tc_tcb;

                        if (SetTCB != NULL) {
                            CTEStructAssert(SetTCB, tcb);
                            CTEGetLock(&SetTCB->tcb_lock, &TCBHandle);
                            //ASSERT(Option->tso_value > SetTCB->tcb_defaultwin);
                            if (DATA_RCV_STATE(SetTCB->tcb_state) &&
                                !CLOSING(SetTCB)) {

                                //  If we are setting the window size
                                //  when scaling is enabled, make sure that the
                                //  scale factor remains same as the one
                                //  which was used in SYN

                                int rcvwinscale = 0;

                                if (Option->tso_value >= SetTCB->tcb_defaultwin) {

                                    if (TcpHostOpts & TCP_FLAG_WS) {

                                        while ((rcvwinscale < TCP_MAX_WINSHIFT) &&
                                               ((TCP_MAXWIN << rcvwinscale) < (int)Conn->tc_window)) {
                                            rcvwinscale++;
                                        }

                                        if (SetTCB->tcb_rcvwinscale != rcvwinscale) {
                                            CTEFreeLock(&SetTCB->tcb_lock, TCBHandle);
                                            CTEFreeLock(&(Conn->tc_ConnBlock->cb_lock), TableHandle);
                                            return TDI_INVALID_PARAMETER;
                                        }
                                    } else {
                                        if (Option->tso_value > 0xFFFF) {
                                            CTEFreeLock(&SetTCB->tcb_lock, TCBHandle);
                                            CTEFreeLock(&(Conn->tc_ConnBlock->cb_lock), TableHandle);
                                            return TDI_INVALID_PARAMETER;
                                        }
                                    }

                                    SetTCB->tcb_flags |= WINDOW_SET;
                                    SetTCB->tcb_defaultwin = Option->tso_value;
                                    REFERENCE_TCB(SetTCB);

                                    CTEFreeLock(&SetTCB->tcb_lock, TCBHandle);
                                    CTEFreeLock(&(Conn->tc_ConnBlock->cb_lock), TableHandle);

                                    SendACK(SetTCB);

                                    CTEGetLock(&SetTCB->tcb_lock, &TCBHandle);
                                    DerefTCB(SetTCB, TCBHandle);

                                    return Status;

                                } else {

                                    CTEFreeLock(&SetTCB->tcb_lock, TCBHandle);
                                    CTEFreeLock(&(Conn->tc_ConnBlock->cb_lock), TableHandle);
                                    return TDI_INVALID_PARAMETER;

                                }

                            } else {
                                CTEFreeLock(&SetTCB->tcb_lock, TCBHandle);
                            }
                        }
                        //CTEFreeLock(&(Conn->tc_ConnBlock->cb_lock), TableHandle);

                    }
                    CTEFreeLock(&(Conn->tc_ConnBlock->cb_lock), TableHandle);
                    //CTEFreeLock(&ConnTableLock, TableHandle);
                    return Status;
                }
                if ((ID->toi_id == TCP_SOCKET_TOS) && !DisableUserTOSSetting) {

                    if ((SetTCB = Conn->tc_tcb)) {
                        CTEGetLock(&SetTCB->tcb_lock, &TCBHandle);
                        KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,"Setting tos  %x %d\n", SetTCB, Option->tso_value));
                        if (Option->tso_value) {
                            SetTCB->tcb_opt.ioi_tos = (uchar) Option->tso_value;
                            Status = TDI_SUCCESS;
                        }
                        CTEFreeLock(&SetTCB->tcb_lock, TCBHandle);
                        CTEFreeLock(&(Conn->tc_ConnBlock->cb_lock), TableHandle);
                        return Status;
                    }
                }
                Flag = 0;
                if (ID->toi_id == TCP_SOCKET_KEEPALIVE_VALS) {
                    TCPKeepalive *Option;
                    // treat it as separate as it takes a structure instead of integer
                    if (Size < sizeof(TCPKeepalive)) {
                        CTEFreeLock(&(Conn->tc_ConnBlock->cb_lock), TableHandle);
                        return Status;
                    }
                    Option = (TCPKeepalive *) Buffer;
                    Value = Option->onoff;
                    if (Value) {
                        Conn->tc_tcbkatime = MS_TO_TICKS(Option->keepalivetime);
                        Conn->tc_tcbkainterval = MS_TO_TICKS(Option->keepaliveinterval);
                    }
                    Flag = KEEPALIVE;
                } else {
                    Option = (TCPSocketOption *) Buffer;
                    Value = Option->tso_value;
                    // We have the connection, so figure out which flag to set.
                    switch (ID->toi_id) {

                    case TCP_SOCKET_NODELAY:
                        Value = !Value;
                        Flag = NAGLING;
                        break;
                    case TCP_SOCKET_KEEPALIVE:
                        Flag = KEEPALIVE;
                        Conn->tc_tcbkatime = KeepAliveTime;
                        Conn->tc_tcbkainterval = KAInterval;
                        break;
                    case TCP_SOCKET_BSDURGENT:
                        Flag = BSD_URGENT;
                        break;
                    case TCP_SOCKET_OOBINLINE:
                        Flag = URG_INLINE;
                        break;
                    case TCP_SOCKET_SCALE_CWIN:
                        Flag = SCALE_CWIN;
                        break;

                    default:
                        Status = TDI_INVALID_PARAMETER;
                        break;
                    }
                }

                if (Status == TDI_SUCCESS) {
                    if (Value)
                        Conn->tc_tcbflags |= Flag;
                    else
                        Conn->tc_tcbflags &= ~Flag;

                    SetTCB = Conn->tc_tcb;
                    if (SetTCB != NULL) {
                        CTEStructAssert(SetTCB, tcb);
                        CTEGetLock(&SetTCB->tcb_lock, &TCBHandle);
                        if (Value)
                            SetTCB->tcb_flags |= Flag;
                        else
                            SetTCB->tcb_flags &= ~Flag;
                        if ((ID->toi_id == TCP_SOCKET_KEEPALIVE) || (ID->toi_id == TCP_SOCKET_KEEPALIVE_VALS))
                        {
                            START_TCB_TIMER_R(SetTCB, KA_TIMER, Conn->tc_tcbkatime);
                            SetTCB->tcb_kacount = 0;
                        }
                        CTEFreeLock(&SetTCB->tcb_lock, TCBHandle);
                    }
                }
                CTEFreeLock(&(Conn->tc_ConnBlock->cb_lock), TableHandle);
            }
            return Status;
        }
        if (ID->toi_type == INFO_TYPE_ADDRESS_OBJECT) {
            // We're setting information on an address object. This is
            // pretty simple.

            return SetAddrOptions(Request, ID->toi_id, Size, Buffer);

        }
        if (ID->toi_type != INFO_TYPE_PROVIDER)
            return TDI_INVALID_PARAMETER;

        if (ID->toi_id == TCP_MIB_TABLE_ID) {
            if (Size != sizeof(TCPConnTableEntry))
                return TDI_INVALID_PARAMETER;

            TCPEntry = (TCPConnTableEntry *) Buffer;

            if (TCPEntry->tct_state != TCP_DELETE_TCB)
                return TDI_INVALID_PARAMETER;

            // We have an apparently valid request. Look up the TCB.

            SetTCB = FindTCB(TCPEntry->tct_localaddr,
                             TCPEntry->tct_remoteaddr, (ushort) TCPEntry->tct_remoteport,
                             (ushort) TCPEntry->tct_localport, &TCBHandle, FALSE, &index);

            // We found him. If he's not closing or closed, close him.
            if (SetTCB != NULL) {

                // We've got him. Bump his ref. count, and call TryToCloseTCB
                // to mark him as closing. Then notify the upper layer client
                // of the disconnect.
                REFERENCE_TCB(SetTCB);
                if (SetTCB->tcb_state != TCB_CLOSED && !CLOSING(SetTCB)) {
                    SetTCB->tcb_flags |= NEED_RST;
                    TryToCloseTCB(SetTCB, TCB_CLOSE_ABORTED, TCBHandle);
                    CTEGetLock(&SetTCB->tcb_lock, &TableHandle);

                    if (SetTCB->tcb_state != TCB_TIME_WAIT) {
                        // Remove him from the TCB, and notify the client.
                        CTEFreeLock(&SetTCB->tcb_lock, TableHandle);
                        RemoveTCBFromConn(SetTCB);
                        NotifyOfDisc(SetTCB, NULL, TDI_CONNECTION_RESET);
                        CTEGetLock(&SetTCB->tcb_lock, &TableHandle);
                    }
                }
                DerefTCB(SetTCB, TableHandle);
                return TDI_SUCCESS;
            } else {

                return TDI_INVALID_PARAMETER;
            }
        } else
            return TDI_INVALID_PARAMETER;

    }
    if (ID->toi_class == INFO_CLASS_IMPLEMENTATION) {
        // We want to return implementation specific info. For now, error out.
        return TDI_INVALID_REQUEST;
    }
    return TDI_INVALID_REQUEST;
}