tech-invite   World Map
3GPP     Specs     Glossaries     UICC       T+       IETF     RFCs     Groups     SIP     ABNFs       Search     Home

RFC 4898

 
 
 

TCP Extended Statistics MIB

Part 3 of 3, p. 41 to 75
Prev RFC Part

 


prevText      Top      Up      ToC       Page 41 
   tcpEStatsStackMSSRcvd  OBJECT-TYPE
       SYNTAX          Unsigned32
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The value received in an MSS option, or zero if none."
       REFERENCE
          "RFC 1122, Requirements for Internet Hosts - Communication
           Layers"
       ::= { tcpEStatsStackEntry 3 }

   tcpEStatsStackWinScaleSent  OBJECT-TYPE
       SYNTAX          Integer32 (-1..14)
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The value of the transmitted window scale option if one was
           sent; otherwise, a value of -1.

           Note that if both tcpEStatsStackWinScaleSent and
           tcpEStatsStackWinScaleRcvd are not -1, then Rcv.Wind.Scale
           will be the same as this value and used to scale receiver
           window announcements from the local host to the remote
           host."
       REFERENCE
          "RFC 1323, TCP Extensions for High Performance"
       ::= { tcpEStatsStackEntry 4 }

   tcpEStatsStackWinScaleRcvd  OBJECT-TYPE
       SYNTAX          Integer32 (-1..14)
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The value of the received window scale option if one was
           received; otherwise, a value of -1.

           Note that if both tcpEStatsStackWinScaleSent and
           tcpEStatsStackWinScaleRcvd are not -1, then Snd.Wind.Scale
           will be the same as this value and used to scale receiver
           window announcements from the remote host to the local
           host."
       REFERENCE
          "RFC 1323, TCP Extensions for High Performance"
       ::= { tcpEStatsStackEntry 5 }

   tcpEStatsStackTimeStamps  OBJECT-TYPE
       SYNTAX          TcpEStatsNegotiated
       MAX-ACCESS      read-only

Top      Up      ToC       Page 42 
       STATUS          current
       DESCRIPTION
          "Enabled(1) if TCP timestamps have been negotiated on,
           selfDisabled(2) if they are disabled or not implemented on
           the local host, or peerDisabled(3) if not negotiated by the
           remote hosts."
       REFERENCE
          "RFC 1323, TCP Extensions for High Performance"
       ::= { tcpEStatsStackEntry 6 }

   tcpEStatsStackECN  OBJECT-TYPE
       SYNTAX          TcpEStatsNegotiated
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "Enabled(1) if Explicit Congestion Notification (ECN) has
           been negotiated on, selfDisabled(2) if it is disabled or
           not implemented on the local host, or peerDisabled(3) if
           not negotiated by the remote hosts."
       REFERENCE
          "RFC 3168, The Addition of Explicit Congestion Notification
           (ECN) to IP"
       ::= { tcpEStatsStackEntry 7 }

   tcpEStatsStackWillSendSACK  OBJECT-TYPE
       SYNTAX          TcpEStatsNegotiated
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "Enabled(1) if the local host will send SACK options,
           selfDisabled(2) if SACK is disabled or not implemented on
           the local host, or peerDisabled(3) if the remote host did
           not send the SACK-permitted option.

           Note that SACK negotiation is not symmetrical.  SACK can
           enabled on one side of the connection and not the other."
       REFERENCE
          "RFC 2018, TCP Selective Acknowledgement Options"
       ::= { tcpEStatsStackEntry 8 }

   tcpEStatsStackWillUseSACK  OBJECT-TYPE
       SYNTAX          TcpEStatsNegotiated
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "Enabled(1) if the local host will process SACK options,
           selfDisabled(2) if SACK is disabled or not implemented on
           the local host, or peerDisabled(3) if the remote host sends

Top      Up      ToC       Page 43 
           duplicate ACKs without SACK options, or the local host
           otherwise decides not to process received SACK options.

           Unlike other TCP options, the remote data receiver cannot
           explicitly indicate if it is able to generate SACK options.
           When sending data, the local host has to deduce if the
           remote receiver is sending SACK options.  This object can
           transition from Enabled(1) to peerDisabled(3) after the SYN
           exchange.

           Note that SACK negotiation is not symmetrical.  SACK can
           enabled on one side of the connection and not the other."
       REFERENCE
          "RFC 2018, TCP Selective Acknowledgement Options"
       ::= { tcpEStatsStackEntry 9 }

   --
   --  The following two objects reflect the current state of the
   --  connection.
   --

   tcpEStatsStackState  OBJECT-TYPE
       SYNTAX          INTEGER {
          tcpESStateClosed(1),
          tcpESStateListen(2),
          tcpESStateSynSent(3),
          tcpESStateSynReceived(4),
          tcpESStateEstablished(5),
          tcpESStateFinWait1(6),
          tcpESStateFinWait2(7),
          tcpESStateCloseWait(8),
          tcpESStateLastAck(9),
          tcpESStateClosing(10),
          tcpESStateTimeWait(11),
          tcpESStateDeleteTcb(12)
       }
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "An integer value representing the connection state from the
           TCP State Transition Diagram.

           The value listen(2) is included only for parallelism to the
           old tcpConnTable, and SHOULD NOT be used because the listen
           state in managed by the tcpListenerTable.

           The value DeleteTcb(12) is included only for parallelism to
           the tcpConnTable mechanism for terminating connections,

Top      Up      ToC       Page 44 
           although this table does not permit writing."
       REFERENCE
          "RFC 793, Transmission Control Protocol"
       ::= { tcpEStatsStackEntry 10 }

   tcpEStatsStackNagle  OBJECT-TYPE
       SYNTAX          TruthValue
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "True(1) if the Nagle algorithm is being used, else
           false(2)."
       REFERENCE
          "RFC 1122, Requirements for Internet Hosts - Communication
           Layers"
       ::= { tcpEStatsStackEntry 11 }

   --
   --  The following objects instrument the overall operation of
   --  TCP congestion control and data retransmissions.  These
   --  instruments are sufficient to fit the actual performance to
   --  an updated macroscopic performance model [RFC2581] [Mat97]
   --  [Pad98].
   --

   tcpEStatsStackMaxSsCwnd  OBJECT-TYPE
       SYNTAX          Gauge32
       UNITS           "octets"
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The maximum congestion window used during Slow Start, in
           octets."
       REFERENCE
          "RFC 2581, TCP Congestion Control"
       ::= { tcpEStatsStackEntry 12 }

   tcpEStatsStackMaxCaCwnd  OBJECT-TYPE
       SYNTAX          Gauge32
       UNITS           "octets"
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The maximum congestion window used during Congestion
           Avoidance, in octets."
       REFERENCE
          "RFC 2581, TCP Congestion Control"
       ::= { tcpEStatsStackEntry 13 }

Top      Up      ToC       Page 45 
   tcpEStatsStackMaxSsthresh  OBJECT-TYPE
       SYNTAX          Gauge32
       UNITS           "octets"
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The maximum slow start threshold, excluding the initial
           value."
       REFERENCE
          "RFC 2581, TCP Congestion Control"
       ::= { tcpEStatsStackEntry 14 }

   tcpEStatsStackMinSsthresh  OBJECT-TYPE
       SYNTAX          Gauge32
       UNITS           "octets"
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The minimum slow start threshold."
       REFERENCE
          "RFC 2581, TCP Congestion Control"
       ::= { tcpEStatsStackEntry 15 }

   tcpEStatsStackInRecovery  OBJECT-TYPE
       SYNTAX          INTEGER {
          tcpESDataContiguous(1),
          tcpESDataUnordered(2),
          tcpESDataRecovery(3)
       }
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "An integer value representing the state of the loss
           recovery for this connection.

           tcpESDataContiguous(1) indicates that the remote receiver
           is reporting contiguous data (no duplicate acknowledgments
           or SACK options) and that there are no unacknowledged
           retransmissions.

           tcpESDataUnordered(2) indicates that the remote receiver is
           reporting missing or out-of-order data (e.g., sending
           duplicate acknowledgments or SACK options) and that there
           are no unacknowledged retransmissions (because the missing
           data has not yet been retransmitted).

           tcpESDataRecovery(3) indicates that the sender has
           outstanding retransmitted data that is still

Top      Up      ToC       Page 46 
           unacknowledged."
       REFERENCE
          "RFC 2581, TCP Congestion Control"
       ::= { tcpEStatsStackEntry 16 }

   tcpEStatsStackDupAcksIn  OBJECT-TYPE
       SYNTAX          ZeroBasedCounter32
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The number of duplicate ACKs received."
       REFERENCE
          "RFC 2581, TCP Congestion Control"
       ::= { tcpEStatsStackEntry 17 }

   tcpEStatsStackSpuriousFrDetected  OBJECT-TYPE
       SYNTAX          ZeroBasedCounter32
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The number of acknowledgments reporting out-of-order
           segments after the Fast Retransmit algorithm has already
           retransmitted the segments. (For example as detected by the
           Eifel algorithm).'"
       REFERENCE
          "RFC 3522, The Eifel Detection Algorithm for TCP"
       ::= { tcpEStatsStackEntry 18 }

   tcpEStatsStackSpuriousRtoDetected  OBJECT-TYPE
       SYNTAX          ZeroBasedCounter32
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The number of acknowledgments reporting segments that have
           already been retransmitted due to a Retransmission Timeout."
       ::= { tcpEStatsStackEntry 19 }

   --
   --  The following optional objects instrument unusual protocol
   --  events that probably indicate implementation problems in
   --  the protocol or path.
   --

   tcpEStatsStackSoftErrors  OBJECT-TYPE
       SYNTAX          ZeroBasedCounter32
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION

Top      Up      ToC       Page 47 
          "The number of segments that fail various consistency tests
           during TCP input processing.  Soft errors might cause the
           segment to be discarded but some do not.  Some of these soft
           errors cause the generation of a TCP acknowledgment, while
           others are silently discarded."
       REFERENCE
          "RFC 793, Transmission Control Protocol"
       ::= { tcpEStatsStackEntry 21 }

   tcpEStatsStackSoftErrorReason  OBJECT-TYPE
       SYNTAX          INTEGER {
          belowDataWindow(1),
          aboveDataWindow(2),
          belowAckWindow(3),
          aboveAckWindow(4),
          belowTSWindow(5),
          aboveTSWindow(6),
          dataCheckSum(7),
          otherSoftError(8)
       }
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "This object identifies which consistency test most recently
           failed during TCP input processing.  This object SHOULD be
           set every time tcpEStatsStackSoftErrors is incremented.  The
           codes are as follows:

           belowDataWindow(1) - All data in the segment is below
           SND.UNA. (Normal for keep-alives and zero window probes).

           aboveDataWindow(2) - Some data in the segment is above
           SND.WND. (Indicates an implementation bug or possible
           attack).

           belowAckWindow(3) - ACK below SND.UNA. (Indicates that the
           return path is reordering ACKs)

           aboveAckWindow(4) - An ACK for data that we have not sent.
           (Indicates an implementation bug or possible attack).

           belowTSWindow(5) - TSecr on the segment is older than the
           current TS.Recent (Normal for the rare case where PAWS
           detects data reordered by the network).

           aboveTSWindow(6) - TSecr on the segment is newer than the
           current TS.Recent. (Indicates an implementation bug or
           possible attack).

Top      Up      ToC       Page 48 
           dataCheckSum(7) - Incorrect checksum.  Note that this value
           is intrinsically fragile, because the header fields used to
           identify the connection may have been corrupted.

           otherSoftError(8) - All other soft errors not listed
           above."
       REFERENCE
          "RFC 793, Transmission Control Protocol"
       ::= { tcpEStatsStackEntry 22 }

   --
   --  The following optional objects expose the detailed
   --  operation of the congestion control algorithms.
   --

   tcpEStatsStackSlowStart  OBJECT-TYPE
       SYNTAX          ZeroBasedCounter32
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The number of times the congestion window has been
           increased by the Slow Start algorithm."
       REFERENCE
          "RFC 2581, TCP Congestion Control"
       ::= { tcpEStatsStackEntry 23 }

   tcpEStatsStackCongAvoid  OBJECT-TYPE
       SYNTAX          ZeroBasedCounter32
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The number of times the congestion window has been
           increased by the Congestion Avoidance algorithm."
       REFERENCE
          "RFC 2581, TCP Congestion Control"
       ::= { tcpEStatsStackEntry 24 }

   tcpEStatsStackOtherReductions  OBJECT-TYPE
       SYNTAX          ZeroBasedCounter32
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The number of congestion window reductions made as a result
           of anything other than AIMD congestion control algorithms.
           Examples of non-multiplicative window reductions include
           Congestion Window Validation [RFC2861] and experimental
           algorithms such as Vegas [Bra94].

Top      Up      ToC       Page 49 
           All window reductions MUST be counted as either
           tcpEStatsPerfCongSignals or tcpEStatsStackOtherReductions."
       REFERENCE
          "RFC 2861, TCP Congestion Window Validation"
       ::= { tcpEStatsStackEntry 25 }

   tcpEStatsStackCongOverCount  OBJECT-TYPE
       SYNTAX          ZeroBasedCounter32
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The number of congestion events that were 'backed out' of
           the congestion control state machine such that the
           congestion window was restored to a prior value.  This can
           happen due to the Eifel algorithm [RFC3522] or other
           algorithms that can be used to detect and cancel spurious
           invocations of the Fast Retransmit Algorithm.

           Although it may be feasible to undo the effects of spurious
           invocation of the Fast Retransmit congestion events cannot
           easily be backed out of tcpEStatsPerfCongSignals and
           tcpEStatsPathPreCongSumCwnd, etc."
       REFERENCE
          "RFC 3522, The Eifel Detection Algorithm for TCP"
       ::= { tcpEStatsStackEntry 26 }

   tcpEStatsStackFastRetran  OBJECT-TYPE
       SYNTAX          ZeroBasedCounter32
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The number of invocations of the Fast Retransmit algorithm."
       REFERENCE
          "RFC 2581, TCP Congestion Control"
       ::= { tcpEStatsStackEntry 27 }

   tcpEStatsStackSubsequentTimeouts  OBJECT-TYPE
       SYNTAX          ZeroBasedCounter32
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The number of times the retransmit timeout has expired after
           the RTO has been doubled.  See Section 5.5 of RFC 2988."
       REFERENCE
          "RFC 2988, Computing TCP's Retransmission Timer"
       ::= { tcpEStatsStackEntry 28 }

Top      Up      ToC       Page 50 
   tcpEStatsStackCurTimeoutCount  OBJECT-TYPE
       SYNTAX          Gauge32
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The current number of times the retransmit timeout has
           expired without receiving an acknowledgment for new data.
           tcpEStatsStackCurTimeoutCount is reset to zero when new
           data is acknowledged and incremented for each invocation of
           Section 5.5 of RFC 2988."
       REFERENCE
          "RFC 2988, Computing TCP's Retransmission Timer"
       ::= { tcpEStatsStackEntry 29 }

   tcpEStatsStackAbruptTimeouts  OBJECT-TYPE
       SYNTAX          ZeroBasedCounter32
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The number of timeouts that occurred without any
           immediately preceding duplicate acknowledgments or other
           indications of congestion.  Abrupt Timeouts indicate that
           the path lost an entire window of data or acknowledgments.

           Timeouts that are preceded by duplicate acknowledgments or
           other congestion signals (e.g., ECN) are not counted as
           abrupt, and might have been avoided by a more sophisticated
           Fast Retransmit algorithm."
       REFERENCE
          "RFC 2581, TCP Congestion Control"
       ::= { tcpEStatsStackEntry 30 }

   tcpEStatsStackSACKsRcvd  OBJECT-TYPE
       SYNTAX          ZeroBasedCounter32
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The number of SACK options received."
       REFERENCE
          "RFC 2018, TCP Selective Acknowledgement Options"
       ::= { tcpEStatsStackEntry 31 }

   tcpEStatsStackSACKBlocksRcvd  OBJECT-TYPE
       SYNTAX          ZeroBasedCounter32
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The number of SACK blocks received (within SACK options)."

Top      Up      ToC       Page 51 
       REFERENCE
          "RFC 2018, TCP Selective Acknowledgement Options"
       ::= { tcpEStatsStackEntry 32 }

   tcpEStatsStackSendStall  OBJECT-TYPE
       SYNTAX          ZeroBasedCounter32
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The number of interface stalls or other sender local
           resource limitations that are treated as congestion
           signals."
       ::= { tcpEStatsStackEntry 33 }

   tcpEStatsStackDSACKDups  OBJECT-TYPE
       SYNTAX          ZeroBasedCounter32
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The number of duplicate segments reported to the local host
           by D-SACK blocks."
       REFERENCE
          "RFC 2883, An Extension to the Selective Acknowledgement
           (SACK) Option for TCP"
       ::= { tcpEStatsStackEntry 34 }

   --
   --  The following optional objects instrument path MTU
   --  discovery.
   --

   tcpEStatsStackMaxMSS  OBJECT-TYPE
       SYNTAX          Gauge32
       UNITS           "octets"
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The maximum MSS, in octets."
       REFERENCE
          "RFC 1191, Path MTU discovery"
       ::= { tcpEStatsStackEntry 35 }

   tcpEStatsStackMinMSS  OBJECT-TYPE
       SYNTAX          Gauge32
       UNITS           "octets"
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION

Top      Up      ToC       Page 52 
          "The minimum MSS, in octets."
       REFERENCE
          "RFC 1191, Path MTU discovery"
       ::= { tcpEStatsStackEntry 36 }

   --
   --  The following optional initial value objects are useful for
   --  conformance testing instruments on application progress and
   --  consumed network resources.
   --

   tcpEStatsStackSndInitial  OBJECT-TYPE
       SYNTAX          Unsigned32
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "Initial send sequence number.  Note that by definition
           tcpEStatsStackSndInitial never changes for a given
           connection."
       REFERENCE
          "RFC 793, Transmission Control Protocol"
       ::= { tcpEStatsStackEntry 37 }

   tcpEStatsStackRecInitial  OBJECT-TYPE
       SYNTAX          Unsigned32
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "Initial receive sequence number.  Note that by definition
           tcpEStatsStackRecInitial never changes for a given
           connection."
       REFERENCE
          "RFC 793, Transmission Control Protocol"
       ::= { tcpEStatsStackEntry 38 }

   --
   --  The following optional objects instrument the senders
   --  buffer usage, including any buffering in the application
   --  interface to TCP and the retransmit queue.  All 'buffer
   --  memory' instruments are assumed to include OS data
   --  structure overhead.
   --

   tcpEStatsStackCurRetxQueue  OBJECT-TYPE
       SYNTAX          Gauge32
       UNITS           "octets"
       MAX-ACCESS      read-only
       STATUS          current

Top      Up      ToC       Page 53 
       DESCRIPTION
          "The current number of octets of data occupying the
           retransmit queue."
       ::= { tcpEStatsStackEntry 39 }

   tcpEStatsStackMaxRetxQueue  OBJECT-TYPE
       SYNTAX          Gauge32
       UNITS           "octets"
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The maximum number of octets of data occupying the
           retransmit queue."
       ::= { tcpEStatsStackEntry 40 }

   tcpEStatsStackCurReasmQueue  OBJECT-TYPE
       SYNTAX          Gauge32
       UNITS           "octets"
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The current number of octets of sequence space spanned by
           the reassembly queue.  This is generally the difference
           between rcv.nxt and the sequence number of the right most
           edge of the reassembly queue."
       ::= { tcpEStatsStackEntry 41 }

   tcpEStatsStackMaxReasmQueue  OBJECT-TYPE
       SYNTAX          Gauge32
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The maximum value of tcpEStatsStackCurReasmQueue"
       ::= { tcpEStatsStackEntry 42 }

   -- ================================================================
   --
   -- Statistics for diagnosing interactions between
   -- applications and TCP.
   --

   tcpEStatsAppTable    OBJECT-TYPE
       SYNTAX      SEQUENCE OF TcpEStatsAppEntry
       MAX-ACCESS  not-accessible
       STATUS      current
       DESCRIPTION
           "This table contains objects that are useful for
           determining if the application using TCP is

Top      Up      ToC       Page 54 
           limiting TCP performance.

           Entries are retained in this table for the number of
           seconds indicated by the tcpEStatsConnTableLatency
           object, after the TCP connection first enters the closed
           state."
       ::= { tcpEStats 6 }

   tcpEStatsAppEntry  OBJECT-TYPE
       SYNTAX       TcpEStatsAppEntry
       MAX-ACCESS   not-accessible
       STATUS       current
       DESCRIPTION
           "Each entry in this table has information about the
           characteristics of each active and recently closed TCP
           connection."
      INDEX { tcpEStatsConnectIndex }
      ::= { tcpEStatsAppTable 1 }

   TcpEStatsAppEntry ::= SEQUENCE {

           tcpEStatsAppSndUna                  Counter32,
           tcpEStatsAppSndNxt                  Unsigned32,
           tcpEStatsAppSndMax                  Counter32,
           tcpEStatsAppThruOctetsAcked         ZeroBasedCounter32,
           tcpEStatsAppHCThruOctetsAcked       ZeroBasedCounter64,
           tcpEStatsAppRcvNxt                  Counter32,
           tcpEStatsAppThruOctetsReceived      ZeroBasedCounter32,
           tcpEStatsAppHCThruOctetsReceived    ZeroBasedCounter64,
           tcpEStatsAppCurAppWQueue            Gauge32,
           tcpEStatsAppMaxAppWQueue            Gauge32,
           tcpEStatsAppCurAppRQueue            Gauge32,
           tcpEStatsAppMaxAppRQueue            Gauge32
       }

   --
   --  The following objects provide throughput statistics for the
   --  connection including sequence numbers and elapsed
   --  application data.  These permit direct observation of the
   --  applications progress, in terms of elapsed data delivery
   --  and elapsed time.
   --

   tcpEStatsAppSndUna  OBJECT-TYPE
       SYNTAX          Counter32
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION

Top      Up      ToC       Page 55 
          "The value of SND.UNA, the oldest unacknowledged sequence
           number.

           Note that SND.UNA is a TCP state variable that is congruent
           to Counter32 semantics."
       REFERENCE
          "RFC 793, Transmission Control Protocol"
       ::= { tcpEStatsAppEntry 1 }

   tcpEStatsAppSndNxt  OBJECT-TYPE
       SYNTAX          Unsigned32
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The value of SND.NXT, the next sequence number to be sent.
           Note that tcpEStatsAppSndNxt is not monotonic (and thus not
           a counter) because TCP sometimes retransmits lost data by
           pulling tcpEStatsAppSndNxt back to the missing data."
       REFERENCE
          "RFC 793, Transmission Control Protocol"
       ::= { tcpEStatsAppEntry 2 }

   tcpEStatsAppSndMax  OBJECT-TYPE
       SYNTAX          Counter32
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The farthest forward (right most or largest) SND.NXT value.
           Note that this will be equal to tcpEStatsAppSndNxt except
           when tcpEStatsAppSndNxt is pulled back during recovery."
       REFERENCE
          "RFC 793, Transmission Control Protocol"
       ::= { tcpEStatsAppEntry 3 }

   tcpEStatsAppThruOctetsAcked  OBJECT-TYPE
       SYNTAX          ZeroBasedCounter32
       UNITS           "octets"
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The number of octets for which cumulative acknowledgments
           have been received.  Note that this will be the sum of
           changes to tcpEStatsAppSndUna."
       ::= { tcpEStatsAppEntry 4 }

   tcpEStatsAppHCThruOctetsAcked  OBJECT-TYPE
       SYNTAX          ZeroBasedCounter64
       UNITS           "octets"

Top      Up      ToC       Page 56 
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The number of octets for which cumulative acknowledgments
           have been received, on systems that can receive more than
           10 million bits per second.  Note that this will be the sum
           of changes in tcpEStatsAppSndUna."
       ::= { tcpEStatsAppEntry 5 }

   tcpEStatsAppRcvNxt  OBJECT-TYPE
       SYNTAX          Counter32
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The value of RCV.NXT.  The next sequence number expected on
           an incoming segment, and the left or lower edge of the
           receive window.

           Note that RCV.NXT is a TCP state variable that is congruent
           to Counter32 semantics."
       REFERENCE
          "RFC 793, Transmission Control Protocol"
       ::= { tcpEStatsAppEntry 6 }

   tcpEStatsAppThruOctetsReceived  OBJECT-TYPE
       SYNTAX          ZeroBasedCounter32
       UNITS           "octets"
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The number of octets for which cumulative acknowledgments
           have been sent.  Note that this will be the sum of changes
           to tcpEStatsAppRcvNxt."
       ::= { tcpEStatsAppEntry 7 }

   tcpEStatsAppHCThruOctetsReceived  OBJECT-TYPE
       SYNTAX          ZeroBasedCounter64
       UNITS           "octets"
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The number of octets for which cumulative acknowledgments
           have been sent, on systems that can transmit more than 10
           million bits per second.  Note that this will be the sum of
           changes in tcpEStatsAppRcvNxt."
       ::= { tcpEStatsAppEntry 8 }

   tcpEStatsAppCurAppWQueue  OBJECT-TYPE

Top      Up      ToC       Page 57 
       SYNTAX          Gauge32
       UNITS           "octets"
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The current number of octets of application data buffered
           by TCP, pending first transmission, i.e., to the left of
           SND.NXT or SndMax.  This data will generally be transmitted
           (and SND.NXT advanced to the left) as soon as there is an
           available congestion window (cwnd) or receiver window
           (rwin).  This is the amount of data readily available for
           transmission, without scheduling the application.  TCP
           performance may suffer if there is insufficient queued
           write data."
       ::= { tcpEStatsAppEntry 11 }

   tcpEStatsAppMaxAppWQueue  OBJECT-TYPE
       SYNTAX          Gauge32
       UNITS           "octets"
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The maximum number of octets of application data buffered
           by TCP, pending first transmission.  This is the maximum
           value of tcpEStatsAppCurAppWQueue.  This pair of objects can
           be used to determine if insufficient queued data is steady
           state (suggesting insufficient queue space) or transient
           (suggesting insufficient application performance or
           excessive CPU load or scheduler latency)."
       ::= { tcpEStatsAppEntry 12 }

   tcpEStatsAppCurAppRQueue  OBJECT-TYPE
       SYNTAX          Gauge32
       UNITS           "octets"
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION
          "The current number of octets of application data that has
           been acknowledged by TCP but not yet delivered to the
           application."
       ::= { tcpEStatsAppEntry 13 }

   tcpEStatsAppMaxAppRQueue  OBJECT-TYPE
       SYNTAX          Gauge32
       UNITS           "octets"
       MAX-ACCESS      read-only
       STATUS          current
       DESCRIPTION

Top      Up      ToC       Page 58 
          "The maximum number of octets of application data that has
           been acknowledged by TCP but not yet delivered to the
           application."
       ::= { tcpEStatsAppEntry 14 }

   -- ================================================================
   --
   -- Controls for Tuning TCP
   --

   tcpEStatsTuneTable    OBJECT-TYPE
       SYNTAX      SEQUENCE OF TcpEStatsTuneEntry
       MAX-ACCESS  not-accessible
       STATUS      current
       DESCRIPTION
           "This table contains per-connection controls that can
           be used to work around a number of common problems that
           plague TCP over some paths.  All can be characterized as
           limiting the growth of the congestion window so as to
           prevent TCP from overwhelming some component in the
           path.

           Entries are retained in this table for the number of
           seconds indicated by the tcpEStatsConnTableLatency
           object, after the TCP connection first enters the closed
           state."
       ::= { tcpEStats 7 }

   tcpEStatsTuneEntry  OBJECT-TYPE
       SYNTAX       TcpEStatsTuneEntry
       MAX-ACCESS   not-accessible
       STATUS       current
       DESCRIPTION
           "Each entry in this table is a control that can be used to
           place limits on each active TCP connection."
      INDEX { tcpEStatsConnectIndex }
      ::= { tcpEStatsTuneTable 1 }

   TcpEStatsTuneEntry ::= SEQUENCE {

           tcpEStatsTuneLimCwnd                Unsigned32,
           tcpEStatsTuneLimSsthresh            Unsigned32,
           tcpEStatsTuneLimRwin                Unsigned32,
           tcpEStatsTuneLimMSS                 Unsigned32
       }

   tcpEStatsTuneLimCwnd  OBJECT-TYPE
       SYNTAX          Unsigned32

Top      Up      ToC       Page 59 
       UNITS           "octets"
       MAX-ACCESS      read-write
       STATUS          current
       DESCRIPTION
          "A control to set the maximum congestion window that may be
           used, in octets."
       REFERENCE
          "RFC 2581, TCP Congestion Control"
       ::= { tcpEStatsTuneEntry 1 }

   tcpEStatsTuneLimSsthresh  OBJECT-TYPE
       SYNTAX          Unsigned32
       UNITS           "octets"
       MAX-ACCESS      read-write
       STATUS          current
       DESCRIPTION
          "A control to limit the maximum queue space (in octets) that
           this TCP connection is likely to occupy during slowstart.

           It can be implemented with the algorithm described in
           RFC 3742 by setting the max_ssthresh parameter to twice
           tcpEStatsTuneLimSsthresh.

           This algorithm can be used to overcome some TCP performance
           problems over network paths that do not have sufficient
           buffering to withstand the bursts normally present during
           slowstart."
       REFERENCE
          "RFC 3742, Limited Slow-Start for TCP with Large Congestion
           Windows"
       ::= { tcpEStatsTuneEntry 2 }

   tcpEStatsTuneLimRwin  OBJECT-TYPE
       SYNTAX          Unsigned32
       UNITS           "octets"
       MAX-ACCESS      read-write
       STATUS          current
       DESCRIPTION
          "A control to set the maximum window advertisement that may
           be sent, in octets."
       REFERENCE
          "RFC 793, Transmission Control Protocol"
       ::= { tcpEStatsTuneEntry 3 }

   tcpEStatsTuneLimMSS  OBJECT-TYPE
       SYNTAX          Unsigned32
       UNITS           "octets"
       MAX-ACCESS      read-write

Top      Up      ToC       Page 60 
       STATUS          current
       DESCRIPTION
          "A control to limit the maximum segment size in octets, that
           this TCP connection can use."
       REFERENCE
          "RFC 1191, Path MTU discovery"
       ::= { tcpEStatsTuneEntry 4 }

   -- ================================================================
   --
   -- TCP Extended Statistics Notifications Group
   --

   tcpEStatsEstablishNotification NOTIFICATION-TYPE
       OBJECTS     {
                     tcpEStatsConnectIndex
                   }
       STATUS      current
       DESCRIPTION
           "The indicated connection has been accepted
           (or alternatively entered the established state)."
       ::= { tcpEStatsNotifications 1 }

   tcpEStatsCloseNotification NOTIFICATION-TYPE
       OBJECTS     {
                     tcpEStatsConnectIndex
                   }
       STATUS      current
       DESCRIPTION
           "The indicated connection has left the
           established state"
       ::= { tcpEStatsNotifications 2 }

   -- ================================================================
   --
   -- Conformance Definitions
   --

      tcpEStatsCompliances   OBJECT IDENTIFIER
           ::= { tcpEStatsConformance 1 }
      tcpEStatsGroups        OBJECT IDENTIFIER
           ::= { tcpEStatsConformance 2 }

   --
   -- Compliance Statements
   --

     tcpEStatsCompliance MODULE-COMPLIANCE

Top      Up      ToC       Page 61 
        STATUS current
        DESCRIPTION
            "Compliance statement for all systems that implement TCP
            extended statistics."
        MODULE -- this module
            MANDATORY-GROUPS {
                               tcpEStatsListenerGroup,
                               tcpEStatsConnectIdGroup,
                               tcpEStatsPerfGroup,
                               tcpEStatsPathGroup,
                               tcpEStatsStackGroup,
                               tcpEStatsAppGroup
                             }
            GROUP tcpEStatsListenerHCGroup
            DESCRIPTION
                "This group is mandatory for all systems that can
                 wrap the values of the 32-bit counters in
                 tcpEStatsListenerGroup in less than one hour."

            GROUP tcpEStatsPerfOptionalGroup
            DESCRIPTION
                "This group is optional for all systems."

            GROUP tcpEStatsPerfHCGroup
            DESCRIPTION
                "This group is mandatory for systems that can
                wrap the values of the 32-bit counters in
                tcpEStatsPerfGroup in less than one hour.

                Note that any system that can attain 10 Mb/s
                can potentially wrap 32-Bit Octet counters in
                under one hour."

            GROUP tcpEStatsPathOptionalGroup
            DESCRIPTION
                "This group is optional for all systems."

            GROUP tcpEStatsPathHCGroup
            DESCRIPTION
                "This group is mandatory for systems that can
                wrap the values of the 32-bit counters in
                tcpEStatsPathGroup in less than one hour.

                Note that any system that can attain 10 Mb/s
                can potentially wrap 32-Bit Octet counters in
                under one hour."

            GROUP tcpEStatsStackOptionalGroup

Top      Up      ToC       Page 62 
            DESCRIPTION
                "This group is optional for all systems."

            GROUP tcpEStatsAppHCGroup
            DESCRIPTION
                "This group is mandatory for systems that can
                wrap the values of the 32-bit counters in
                tcpEStatsStackGroup in less than one hour.

                Note that any system that can attain 10 Mb/s
                can potentially wrap 32-Bit Octet counters in
                under one hour."

            GROUP tcpEStatsAppOptionalGroup
            DESCRIPTION
                "This group is optional for all systems."

            GROUP tcpEStatsTuneOptionalGroup
            DESCRIPTION
                "This group is optional for all systems."

            GROUP tcpEStatsNotificationsGroup
            DESCRIPTION
                "This group is optional for all systems."

            GROUP tcpEStatsNotificationsCtlGroup
            DESCRIPTION
                "This group is mandatory for systems that include the
                 tcpEStatsNotificationGroup."

      ::= { tcpEStatsCompliances 1 }

   -- ================================================================
   --
   -- Units of Conformance
   --
       tcpEStatsListenerGroup  OBJECT-GROUP
            OBJECTS {
                 tcpEStatsListenerTableLastChange,
                 tcpEStatsListenerStartTime,
                 tcpEStatsListenerSynRcvd,
                 tcpEStatsListenerInitial,
                 tcpEStatsListenerEstablished,
                 tcpEStatsListenerAccepted,
                 tcpEStatsListenerExceedBacklog,
                 tcpEStatsListenerCurConns,
                 tcpEStatsListenerMaxBacklog,
                 tcpEStatsListenerCurBacklog,

Top      Up      ToC       Page 63 
                 tcpEStatsListenerCurEstabBacklog
            }
            STATUS current
            DESCRIPTION
                 "The tcpEStatsListener group includes objects that
                 provide valuable statistics and debugging
                 information for TCP Listeners."
         ::= { tcpEStatsGroups 1 }

       tcpEStatsListenerHCGroup  OBJECT-GROUP
            OBJECTS {
                 tcpEStatsListenerHCSynRcvd,
                 tcpEStatsListenerHCInitial,
                 tcpEStatsListenerHCEstablished,
                 tcpEStatsListenerHCAccepted,
                 tcpEStatsListenerHCExceedBacklog
            }
            STATUS current
            DESCRIPTION
                 "The tcpEStatsListenerHC group includes 64-bit
                  counters in tcpEStatsListenerTable."
         ::= { tcpEStatsGroups 2 }

       tcpEStatsConnectIdGroup  OBJECT-GROUP
            OBJECTS {
                 tcpEStatsConnTableLatency,
                 tcpEStatsConnectIndex
            }
            STATUS current
            DESCRIPTION
                 "The tcpEStatsConnectId group includes objects that
                 identify TCP connections and control how long TCP
                 connection entries are retained in the tables."
         ::= { tcpEStatsGroups 3 }

       tcpEStatsPerfGroup  OBJECT-GROUP
            OBJECTS {
                 tcpEStatsPerfSegsOut, tcpEStatsPerfDataSegsOut,
                 tcpEStatsPerfDataOctetsOut,
                 tcpEStatsPerfSegsRetrans,
                 tcpEStatsPerfOctetsRetrans, tcpEStatsPerfSegsIn,
                 tcpEStatsPerfDataSegsIn,
                 tcpEStatsPerfDataOctetsIn,
                 tcpEStatsPerfElapsedSecs,
                 tcpEStatsPerfElapsedMicroSecs,
                 tcpEStatsPerfStartTimeStamp, tcpEStatsPerfCurMSS,
                 tcpEStatsPerfPipeSize, tcpEStatsPerfMaxPipeSize,
                 tcpEStatsPerfSmoothedRTT, tcpEStatsPerfCurRTO,

Top      Up      ToC       Page 64 
                 tcpEStatsPerfCongSignals, tcpEStatsPerfCurCwnd,
                 tcpEStatsPerfCurSsthresh, tcpEStatsPerfTimeouts,
                 tcpEStatsPerfCurRwinSent,
                 tcpEStatsPerfMaxRwinSent,
                 tcpEStatsPerfZeroRwinSent,
                 tcpEStatsPerfCurRwinRcvd,
                 tcpEStatsPerfMaxRwinRcvd,
                 tcpEStatsPerfZeroRwinRcvd
            }
            STATUS current
            DESCRIPTION
                 "The tcpEStatsPerf group includes those objects that
                 provide basic performance data for a TCP connection."
         ::= { tcpEStatsGroups 4 }

       tcpEStatsPerfOptionalGroup  OBJECT-GROUP
            OBJECTS {
                 tcpEStatsPerfSndLimTransRwin,
                 tcpEStatsPerfSndLimTransCwnd,
                 tcpEStatsPerfSndLimTransSnd,
                 tcpEStatsPerfSndLimTimeRwin,
                 tcpEStatsPerfSndLimTimeCwnd,
                 tcpEStatsPerfSndLimTimeSnd
            }
            STATUS current
            DESCRIPTION
                 "The tcpEStatsPerf group includes those objects that
                 provide basic performance data for a TCP connection."
         ::= { tcpEStatsGroups 5 }

       tcpEStatsPerfHCGroup  OBJECT-GROUP
            OBJECTS {
                 tcpEStatsPerfHCDataOctetsOut,
                 tcpEStatsPerfHCDataOctetsIn
            }
            STATUS current
            DESCRIPTION
                 "The tcpEStatsPerfHC group includes 64-bit
                 counters in the tcpEStatsPerfTable."
         ::= { tcpEStatsGroups 6 }


       tcpEStatsPathGroup  OBJECT-GROUP
            OBJECTS {
                 tcpEStatsControlPath,
                 tcpEStatsPathRetranThresh,
                 tcpEStatsPathNonRecovDAEpisodes,
                 tcpEStatsPathSumOctetsReordered,

Top      Up      ToC       Page 65 
                 tcpEStatsPathNonRecovDA
            }
            STATUS current
            DESCRIPTION
                 "The tcpEStatsPath group includes objects that
                 control the creation of the tcpEStatsPathTable,
                 and provide information about the path
                 for each TCP connection."
         ::= { tcpEStatsGroups 7 }

       tcpEStatsPathOptionalGroup  OBJECT-GROUP
            OBJECTS {
                 tcpEStatsPathSampleRTT, tcpEStatsPathRTTVar,
                 tcpEStatsPathMaxRTT, tcpEStatsPathMinRTT,
                 tcpEStatsPathSumRTT, tcpEStatsPathCountRTT,
                 tcpEStatsPathMaxRTO, tcpEStatsPathMinRTO,
                 tcpEStatsPathIpTtl, tcpEStatsPathIpTosIn,
                 tcpEStatsPathIpTosOut,
                 tcpEStatsPathPreCongSumCwnd,
                 tcpEStatsPathPreCongSumRTT,
                 tcpEStatsPathPostCongSumRTT,
                 tcpEStatsPathPostCongCountRTT,
                 tcpEStatsPathECNsignals,
                 tcpEStatsPathDupAckEpisodes, tcpEStatsPathRcvRTT,
                 tcpEStatsPathDupAcksOut, tcpEStatsPathCERcvd,
                 tcpEStatsPathECESent
            }
            STATUS current
            DESCRIPTION
                 "The tcpEStatsPath group includes objects that
                 provide additional information about the path
                 for each TCP connection."
         ::= { tcpEStatsGroups 8 }

     tcpEStatsPathHCGroup  OBJECT-GROUP
            OBJECTS {
                 tcpEStatsPathHCSumRTT
            }
            STATUS current
            DESCRIPTION
                 "The tcpEStatsPathHC group includes 64-bit
                 counters in the tcpEStatsPathTable."
         ::= { tcpEStatsGroups 9 }

       tcpEStatsStackGroup  OBJECT-GROUP
            OBJECTS {
                 tcpEStatsControlStack,
                 tcpEStatsStackActiveOpen, tcpEStatsStackMSSSent,

Top      Up      ToC       Page 66 
                 tcpEStatsStackMSSRcvd, tcpEStatsStackWinScaleSent,
                 tcpEStatsStackWinScaleRcvd,
                 tcpEStatsStackTimeStamps, tcpEStatsStackECN,
                 tcpEStatsStackWillSendSACK,
                 tcpEStatsStackWillUseSACK, tcpEStatsStackState,
                 tcpEStatsStackNagle, tcpEStatsStackMaxSsCwnd,
                 tcpEStatsStackMaxCaCwnd,
                 tcpEStatsStackMaxSsthresh,
                 tcpEStatsStackMinSsthresh,
                 tcpEStatsStackInRecovery, tcpEStatsStackDupAcksIn,
                 tcpEStatsStackSpuriousFrDetected,
                 tcpEStatsStackSpuriousRtoDetected
            }
            STATUS current
            DESCRIPTION
                 "The tcpEStatsConnState group includes objects that
                 control the creation of the tcpEStatsStackTable,
                 and provide information about the operation of
                 algorithms used within TCP."
         ::= { tcpEStatsGroups 10 }

       tcpEStatsStackOptionalGroup  OBJECT-GROUP
            OBJECTS {
                 tcpEStatsStackSoftErrors,
                 tcpEStatsStackSoftErrorReason,
                 tcpEStatsStackSlowStart, tcpEStatsStackCongAvoid,
                 tcpEStatsStackOtherReductions,
                 tcpEStatsStackCongOverCount,
                 tcpEStatsStackFastRetran,
                 tcpEStatsStackSubsequentTimeouts,
                 tcpEStatsStackCurTimeoutCount,
                 tcpEStatsStackAbruptTimeouts,
                 tcpEStatsStackSACKsRcvd,
                 tcpEStatsStackSACKBlocksRcvd,
                 tcpEStatsStackSendStall, tcpEStatsStackDSACKDups,
                 tcpEStatsStackMaxMSS, tcpEStatsStackMinMSS,
                 tcpEStatsStackSndInitial,
                 tcpEStatsStackRecInitial,
                 tcpEStatsStackCurRetxQueue,
                 tcpEStatsStackMaxRetxQueue,
                 tcpEStatsStackCurReasmQueue,
                 tcpEStatsStackMaxReasmQueue
            }
            STATUS current
            DESCRIPTION
                 "The tcpEStatsConnState group includes objects that
                 provide additional information about the operation of
                 algorithms used within TCP."

Top      Up      ToC       Page 67 
         ::= { tcpEStatsGroups 11 }

       tcpEStatsAppGroup  OBJECT-GROUP
            OBJECTS {
                 tcpEStatsControlApp,
                 tcpEStatsAppSndUna, tcpEStatsAppSndNxt,
                 tcpEStatsAppSndMax, tcpEStatsAppThruOctetsAcked,
                 tcpEStatsAppRcvNxt,
                 tcpEStatsAppThruOctetsReceived
            }
            STATUS current
            DESCRIPTION
                 "The tcpEStatsConnState group includes objects that
                 control the creation of the tcpEStatsAppTable,
                 and provide information about the operation of
                 algorithms used within TCP."
         ::= { tcpEStatsGroups 12 }

     tcpEStatsAppHCGroup  OBJECT-GROUP
            OBJECTS {
                 tcpEStatsAppHCThruOctetsAcked,
                 tcpEStatsAppHCThruOctetsReceived
            }
            STATUS current
            DESCRIPTION
                 "The tcpEStatsStackHC group includes 64-bit
                 counters in the tcpEStatsStackTable."
         ::= { tcpEStatsGroups 13 }

       tcpEStatsAppOptionalGroup  OBJECT-GROUP
            OBJECTS {
                 tcpEStatsAppCurAppWQueue,
                 tcpEStatsAppMaxAppWQueue,
                 tcpEStatsAppCurAppRQueue,
                 tcpEStatsAppMaxAppRQueue
            }
            STATUS current
            DESCRIPTION
                 "The tcpEStatsConnState group includes objects that
                 provide additional information about how applications
                 are interacting with each TCP connection."
         ::= { tcpEStatsGroups 14 }

       tcpEStatsTuneOptionalGroup  OBJECT-GROUP
            OBJECTS {
                 tcpEStatsControlTune,
                 tcpEStatsTuneLimCwnd, tcpEStatsTuneLimSsthresh,
                 tcpEStatsTuneLimRwin, tcpEStatsTuneLimMSS

Top      Up      ToC       Page 68 
            }
            STATUS current
            DESCRIPTION
                 "The tcpEStatsConnState group includes objects that
                 control the creation of the tcpEStatsConnectionTable,
                 which can be used to set tuning parameters
                 for each TCP connection."
         ::= { tcpEStatsGroups 15 }

       tcpEStatsNotificationsGroup      NOTIFICATION-GROUP
            NOTIFICATIONS {
                          tcpEStatsEstablishNotification,
                          tcpEStatsCloseNotification
            }
            STATUS   current
            DESCRIPTION
                "Notifications sent by a TCP extended statistics agent."
         ::= { tcpEStatsGroups 16 }

       tcpEStatsNotificationsCtlGroup  OBJECT-GROUP
            OBJECTS {
                          tcpEStatsControlNotify
            }
            STATUS   current
            DESCRIPTION
                "The tcpEStatsNotificationsCtl group includes the
                 object that controls the creation of the events
                 in the tcpEStatsNotificationsGroup."
         ::= { tcpEStatsGroups 17 }

      END

Top      Up      ToC       Page 69 
5.  Security Considerations

   There are a number of management objects defined in this MIB module
   with a MAX-ACCESS clause of read-write and/or read-create.  Such
   objects may be considered sensitive or vulnerable in some network
   environments.  The support for SET operations in a non-secure
   environment without proper protection can have a negative effect on
   network operations.  These are the tables and objects and their
   sensitivity/vulnerability:

   *  Changing tcpEStatsConnTableLatency or any of the control objects
      in the tcpEStatsControl group (tcpEStatsControlPath,
      tcpEStatsControlStack, tcpEStatsControlApp, tcpEStatsControlTune)
      may affect the correctness of other management applications
      accessing this MIB.  Generally, local policy should only permit
      limited write access to these controls (e.g., only by one
      management station or only during system configuration).

   *  The objects in the tcpEStatsControlTune group
      (tcpEStatsTuneLimCwnd, tcpEStatsTuneLimSsthresh,
      tcpEStatsTuneLimRwin) can be used to limit resources consumed by
      TCP connections or to limit TCP throughput.  An attacker might
      manipulate these objects to reduce performance to levels below the
      minimum acceptable for a particular application.

   Some of the readable objects in this MIB module (i.e., objects with a
   MAX-ACCESS other than not-accessible) may be considered sensitive or
   vulnerable in some network environments.  It is thus important to
   control even GET and/or NOTIFY access to these objects and possibly
   to even encrypt the values of these objects when sending them over
   the network via SNMP.  These are the tables and objects and their
   sensitivity/vulnerability:

   *  All objects which expose TCP sequence numbers (tcpEStatsAppSndUna,
      tcpEStatsAppSndNxt, tcpEStatsAppSndMax, tcpEStatsStackSndInitial,
      tcpEStatsAppRcvNxt, and tcpEStatsStackRecInitial) might make it
      easier for an attacker to forge in sequence TCP segments to
      disrupt TCP connections.

   *  Nearly all objects in this (or any other) MIB may be used to
      estimate traffic volumes, which may reveal unanticipated
      information about an organization to the outside world.

   SNMP versions prior to SNMPv3 did not include adequate security.
   Even if the network itself is secure (for example by using IPsec),
   even then, there is no control as to who on the secure network is
   allowed to access and GET/SET (read/change/create/delete) the objects
   in this MIB module.

Top      Up      ToC       Page 70 
   It is RECOMMENDED that implementers consider the security features as
   provided by the SNMPv3 framework (see [RFC3410], section 8),
   including full support for the SNMPv3 cryptographic mechanisms (for
   authentication and privacy).

   Further, deployment of SNMP versions prior to SNMPv3 is NOT
   RECOMMENDED.  Instead, it is RECOMMENDED to deploy SNMPv3 and to
   enable cryptographic security.  It is then a customer/operator
   responsibility to ensure that the SNMP entity giving access to an
   instance of this MIB module is properly configured to give access to
   the objects only to those principals (users) that have legitimate
   rights to indeed GET or SET (change/create/delete) them.

6.  IANA Considerations

   The MIB module in this document uses the following IANA-assigned
   OBJECT IDENTIFIER values recorded in the SMI Numbers registry:

          Descriptor        OBJECT IDENTIFIER value
          ------------      -----------------------
          tcpEStatsMIB      { mib-2 156 }

7.  Normative References

   [RFC791]   Postel, J., "Internet Protocol", STD 5, RFC 791, September
              1981.

   [RFC793]   Postel, J., "Transmission Control Protocol", STD 7, RFC
              793, September 1981.

   [RFC1122]  Braden, R., Ed., "Requirements for Internet Hosts -
              Communication Layers", STD 3, RFC 1122, October 1989.

   [RFC1191]  Mogul, J. and S. Deering, "Path MTU discovery", RFC 1191,
              November 1990.

   [RFC1323]  Jacobson, V., Braden, R., and D. Borman, "TCP Extensions
              for High Performance", RFC 1323, May 1992.

   [RFC2018]  Mathis, M., Mahdavi, J., Floyd, S., and A. Romanow, "TCP
              Selective Acknowledgment Options", RFC 2018, October 1996.

   [RFC2119]  Bradner, S., "Key words for use in RFCs to Indicate
              Requirement Levels", BCP 14, RFC 2119, March 1997.

Top      Up      ToC       Page 71 
   [RFC2578]  McCloghrie, K., Perkins, D., Schoenwaelder, J., Case, J.,
              Rose, M., and S. Waldbusser, "Structure of Management
              Information Version 2 (SMIv2)", STD 58, RFC 2578, April
              1999.

   [RFC2579]  McCloghrie, K., Perkins, D., Schoenwaelder, J., Case, J.,
              Rose, M., and S. Waldbusser, "Textual Conventions for
              SMIv2", RFC 2579, STD 58, April 1999.

   [RFC2580]  McCloghrie, K., Perkins, D., Schoenwaelder, J., Case, J.,
              Rose, M., and S. Waldbusser, "Conformance Statements for
              SMIv2", RFC 2580, STD 58, April 1999.

   [RFC2581]  Allman, M., Paxson, V., and W. Stevens, "TCP Congestion
              Control", RFC 2581, April 1999.

   [RFC2856]  Bierman, A., McCloghrie, K., and R. Presuhn, "Textual
              Conventions for Additional High Capacity Data Types", RFC
              2856, June 2000.

   [RFC2883]  Floyd, S., Mahdavi, J., Mathis, M., and M. Podolsky, "An
              Extension to the Selective Acknowledgement (SACK) Option
              for TCP", RFC 2883, July 2000.

   [RFC2988]  Paxson, V. and M. Allman, "Computing TCP's Retransmission
              Timer", RFC 2988, November 2000.

   [RFC3168]  Ramakrishnan, K., Floyd, S., and D. Black, "The Addition
              of Explicit Congestion Notification (ECN) to IP", RFC
              3168, September 2001.

   [RFC3517]  Blanton, E., Allman, M., Fall, K., and L. Wang, "A
              Conservative Selective Acknowledgment (SACK)-based Loss
              Recovery Algorithm for TCP", RFC 3517, April 2003.

   [RFC4022]  Raghunarayan, R., Ed., "Management Information Base for
              the Transmission Control Protocol (TCP)", RFC 4022, March
              2005.

   [RFC4502]  Waldbusser, S., "Remote Network Monitoring Management
              Information Base Version 2", RFC 4502, May 2006.

Top      Up      ToC       Page 72 
8.  Informative References

   [Mat97]    M. Mathis, J. Semke, J. Mahdavi, T. Ott, "The Macroscopic
              Behavior of the TCP Congestion Avoidance Algorithm",
              Computer Communication Review, volume 27, number 3, July
              1997.

   [Bra94]    Brakmo, L., O'Malley, S., "TCP Vegas, New Techniques for
              Congestion Detection and Avoidance", SIGCOMM'94, London,
              pp 24-35, October 1994.

   [Edd06]    Eddy, W., "TCP SYN Flooding Attacks and Common
              Mitigations", Work in Progress, May 2007.

   [POSIX]    Portable Operating System Interface, IEEE Std 1003.1

   [Pad98]    Padhye, J., Firoiu, V., Towsley, D., Kurose, J., "Modeling
              TCP Throughput: A Simple Model and its Empirical
              Validation", SIGCOMM'98.

   [Web100]   Mathis, M., J. Heffner, R. Reddy, "Web100: Extended TCP
              Instrumentation for Research, Education and Diagnosis",
              ACM Computer Communications Review, Vol 33, Num 3, July
              2003.

   [RFC2861]  Handley, M., Padhye, J., and S. Floyd, "TCP Congestion
              Window Validation", RFC 2861, June 2000.

   [RFC3260]  Grossman, D., "New Terminology and Clarifications for
              Diffserv", RFC 3260, April 2002.

   [RFC3410]  Case, J., Mundy, R., Partain, D. and B. Stewart,
              "Introduction and Applicability Statements for Internet-
              Standard Management Framework", RFC 3410, December 2002.

   [RFC3522]  Ludwig, R. and M. Meyer, "The Eifel Detection Algorithm
              for TCP", RFC 3522, April 2003.

   [RFC3742]  Floyd, S., "Limited Slow-Start for TCP with Large
              Congestion Windows", RFC 3742, March 2004.

   [RFC4614]  Duke M., Braden, R., Eddy, W., Blanton, E.  "A Roadmap for
              Transmission Control Protocol (TCP) Specification
              Documents", RFC 4614, September 2006.

Top      Up      ToC       Page 73 
9.  Contributors

   The following people contributed text that was incorporated into this
   document:

   Jon Saperia <saperia@jdscons.com> converted Web100 internal
   documentation into a true MIB.

   Some of the objects in this document were moved from an early version
   of the TCP-MIB by Bill Fenner, et al.

   Some of the object descriptions are based on an earlier unpublished
   document by Jeff Semke.

10.  Acknowledgments

   This document is a product of the Web100 project (www.web100.org), a
   joint effort of Pittsburgh Supercomputing Center (www.psc.edu),
   National Center for Atmospheric Research (www.ncar.ucar.edu), and
   National Center for Supercomputer Applications (www.ncsa.edu).

   It would not have been possible without all of the hard work by the
   entire Web100 team, especially Peter O'Neal, who read and reread the
   entire document several times; Janet Brown and Marla Meehl, who
   patiently managed the unmanageable.  The Web100 project would not
   have been successful without all of the early adopters who suffered
   our bugs to provide many good suggestions and insights into their
   needs for TCP instrumentation.

   Web100 was supported by the National Science Foundation under Grant
   No. 0083285 and a research grant from Cisco Systems.

   We would also like to thank all of the people who built experimental
   implementations of this MIB from early versions and provided us with
   constructive feedback:  Glenn Turner at AARnet, Kristine Adamson at
   IBM, and Xinyan Zan at Microsoft.

   And last, but not least, we would like to thank Dan Romascanu, our
   "MIB Doctor" and Bert Wijnen, the Operations Area Director, for
   patiently steering us through the MIB review process.

Top      Up      ToC       Page 74 
Authors' Addresses

   Matt Mathis
   Pittsburgh Supercomputing Center
   300 S. Craig St.
   Pittsburgh, PA 15213
   Phone: 412-268-4960
   EMail: mathis@psc.edu

   John Heffner
   Pittsburgh Supercomputing Center
   300 S. Craig St.
   Pittsburgh, PA 15213
   Phone: 412-268-4960
   EMail: jheffner@psc.edu

   Rajiv Raghunarayan
   Cisco Systems Inc.
   San Jose, CA 95134
   Phone: 408 853 9612
   EMail: raraghun@cisco.com

Top      Up      ToC       Page 75 
Full Copyright Statement

   Copyright (C) The IETF Trust (2007).

   This document is subject to the rights, licenses and restrictions
   contained in BCP 78, and except as set forth therein, the authors
   retain all their rights.

   This document and the information contained herein are provided on an
   "AS IS" basis and THE CONTRIBUTOR, THE ORGANIZATION HE/SHE REPRESENTS
   OR IS SPONSORED BY (IF ANY), THE INTERNET SOCIETY, THE IETF TRUST AND
   THE INTERNET ENGINEERING TASK FORCE DISCLAIM ALL WARRANTIES, EXPRESS
   OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF
   THE INFORMATION HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED
   WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.

Intellectual Property

   The IETF takes no position regarding the validity or scope of any
   Intellectual Property Rights or other rights that might be claimed to
   pertain to the implementation or use of the technology described in
   this document or the extent to which any license under such rights
   might or might not be available; nor does it represent that it has
   made any independent effort to identify any such rights.  Information
   on the procedures with respect to rights in RFC documents can be
   found in BCP 78 and BCP 79.

   Copies of IPR disclosures made to the IETF Secretariat and any
   assurances of licenses to be made available, or the result of an
   attempt made to obtain a general license or permission for the use of
   such proprietary rights by implementers or users of this
   specification can be obtained from the IETF on-line IPR repository at
   http://www.ietf.org/ipr.

   The IETF invites any interested party to bring to its attention any
   copyrights, patents or patent applications, or other proprietary
   rights that may cover technology that may be required to implement
   this standard.  Please address the information to the IETF at
   ietf-ipr@ietf.org.

Acknowledgement

   Funding for the RFC Editor function is currently provided by the
   Internet Society.