-- =================================================================
-- Description: DIFFSERV-MIB
-- Reference:   This mib was extracted from RFC 3289
-- =================================================================
    DIFFSERV-MIB DEFINITIONS ::= BEGIN
    
        IMPORTS
        Unsigned32, Counter64, MODULE-IDENTITY, OBJECT-TYPE,
        OBJECT-IDENTITY, zeroDotZero, mib-2
            FROM SNMPv2-SMI
        TEXTUAL-CONVENTION, RowStatus, RowPointer,
        StorageType, AutonomousType
            FROM SNMPv2-TC
        MODULE-COMPLIANCE, OBJECT-GROUP
            FROM SNMPv2-CONF
        ifIndex, InterfaceIndexOrZero
            FROM IF-MIB
        InetAddressType, InetAddress, InetAddressPrefixLength,
        InetPortNumber
            FROM INET-ADDRESS-MIB
        BurstSize
            FROM INTEGRATED-SERVICES-MIB
        Dscp, DscpOrAny
            FROM DIFFSERV-DSCP-TC;
    
    diffServMib MODULE-IDENTITY
        LAST-UPDATED "200202070000Z"
        ORGANIZATION "IETF Differentiated Services WG"
        CONTACT-INFO
            "   Fred Baker
                Cisco Systems
                1121 Via Del Rey
                Santa Barbara, CA 93117, USA
                E-mail: fred@cisco.com
                
                Kwok Ho Chan
                Nortel Networks
                600 Technology Park Drive
                Billerica, MA 01821, USA
                E-mail: khchan@nortelnetworks.com
                
                Andrew Smith
                Harbour Networks
                Jiuling Building
                
                21 North Xisanhuan Ave.
                Beijing, 100089, PRC
                E-mail: ah_smith@acm.org
                
                Differentiated Services Working Group:
                diffserv@ietf.org"
        DESCRIPTION
            "This MIB defines the objects necessary to manage a device that
            uses the Differentiated Services Architecture described in RFC
            2475. The Conceptual Model of a Differentiated Services Router
            provides supporting information on how such a router is modeled."
        REVISION "200202070000Z"
        DESCRIPTION
            "Initial version, published as RFC 3289."
        ::= { mib-2 97 }
    
    diffServMIBObjects     OBJECT IDENTIFIER ::= { diffServMib 1 }
    diffServMIBConformance OBJECT IDENTIFIER ::= { diffServMib 2 }
    diffServMIBAdmin       OBJECT IDENTIFIER ::= { diffServMib 3 }
    
    IndexInteger ::= TEXTUAL-CONVENTION
        DISPLAY-HINT "d"
        STATUS   current
        DESCRIPTION
            "An integer which may be used as a table index."
        SYNTAX   Unsigned32 (1..4294967295)
    
    IndexIntegerNextFree ::= TEXTUAL-CONVENTION
        DISPLAY-HINT "d"
        STATUS   current
        DESCRIPTION
            "An integer which may be used as a new Index in a table.
    
            The special value of 0 indicates that no more new entries can be
            created in the relevant table.
    
            When a MIB is used for configuration, an object with this SYNTAX
            always contains a legal value (if non-zero) for an index that is
            not currently used in the relevant table. The Command Generator
            (Network Management Application) reads this variable and uses the
            (non-zero) value read when creating a new row with an SNMP SET.
            When the SET is performed, the Command Responder (agent) must
            determine whether the value is indeed still unused; Two Network
            Management Applications may attempt to create a row
            (configuration entry) simultaneously and use the same value. If
            it is currently unused, the SET succeeds and the Command
            Responder (agent) changes the value of this object, according to
            an implementation-specific algorithm.  If the value is in use,
            however, the SET fails.  The Network Management Application must
            then re-read this variable to obtain a new usable value.
    
            An OBJECT-TYPE definition using this SYNTAX MUST specify the
            relevant table for which the object is providing this
            functionality."
        SYNTAX   Unsigned32 (0..4294967295)
    
    IfDirection ::= TEXTUAL-CONVENTION
        STATUS current
        DESCRIPTION
            "IfDirection specifies a direction of data travel on an
            interface. 'inbound' traffic is operated on during reception from
            the interface, while 'outbound' traffic is operated on prior to
            transmission on the interface."
        SYNTAX  INTEGER {
            inbound(1),     -- ingress interface
            outbound(2)     -- egress interface
            }
    
    --
    -- Data Path
    --
    
    diffServDataPath        OBJECT IDENTIFIER ::= { diffServMIBObjects 1 }
    
    --
    -- Data Path Table
    --
    -- The Data Path Table enumerates the Differentiated Services
    -- Functional Data Paths within this device.  Each entry in this table
    -- is indexed by ifIndex and ifDirection.  Each entry provides the
    -- first Differentiated Services Functional Data Path Element to
    -- process data flowing along specific data path.  This table should
    -- have at most two entries for each interface capable of
    -- Differentiated Services processing on this device: ingress and
    -- egress.
    
    -- Note that Differentiated Services Functional Data Path Elements
    -- linked together using their individual next pointers and anchored by
    -- an entry of the diffServDataPathTable constitute a functional data
    -- path.
    --
    
    diffServDataPathTable OBJECT-TYPE
        SYNTAX        SEQUENCE OF DiffServDataPathEntry
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "The data path table contains RowPointers indicating the start of
            the functional data path for each interface and traffic direction
            in this device. These may merge, or be separated into parallel
            data paths."
        ::= { diffServDataPath 1 }
    
    diffServDataPathEntry OBJECT-TYPE
        SYNTAX        DiffServDataPathEntry
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "An entry in the data path table indicates the start of a single
            Differentiated Services Functional Data Path in this device.
    
            These are associated with individual interfaces, logical or
            physical, and therefore are instantiated by ifIndex. Therefore,
            the interface index must have been assigned, according to the
            procedures applicable to that, before it can be meaningfully
            used. Generally, this means that the interface must exist.
    
            When diffServDataPathStorage is of type nonVolatile, however,
            this may reflect the configuration for an interface whose ifIndex
            has been assigned but for which the supporting implementation is
            not currently present."
        INDEX { ifIndex, diffServDataPathIfDirection }
        ::= { diffServDataPathTable 1 }
    
    DiffServDataPathEntry ::= SEQUENCE  {
        diffServDataPathIfDirection    IfDirection,
        diffServDataPathStart           RowPointer,
        diffServDataPathStorage         StorageType,
        diffServDataPathStatus          RowStatus
        }
    
    diffServDataPathIfDirection OBJECT-TYPE
        SYNTAX        IfDirection
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "IfDirection specifies whether the reception or transmission path
            for this interface is in view."
        ::= { diffServDataPathEntry 1 }
    
    diffServDataPathStart OBJECT-TYPE
        SYNTAX        RowPointer
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "This selects the first Differentiated Services Functional Data
            Path Element to handle traffic for this data path. This
            RowPointer should point to an instance of one of:
              diffServClfrEntry
              diffServMeterEntry
              diffServActionEntry
              diffServAlgDropEntry
              diffServQEntry
    
            A value of zeroDotZero in this attribute indicates that no
            Differentiated Services treatment is performed on traffic of this
            data path. A pointer with the value zeroDotZero normally
            terminates a functional data path.
    
            Setting this to point to a target that does not exist results in
            an inconsistentValue error.  If the row pointed to is removed or
            becomes inactive by other means, the treatment is as if this
            attribute contains a value of zeroDotZero."
        ::= { diffServDataPathEntry 2 }
    
    diffServDataPathStorage OBJECT-TYPE
        SYNTAX        StorageType
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The storage type for this conceptual row.  Conceptual rows
            having the value 'permanent' need not allow write-access to any
            columnar objects in the row."
        DEFVAL { nonVolatile }
        ::= { diffServDataPathEntry 3 }
    
    diffServDataPathStatus OBJECT-TYPE
        SYNTAX        RowStatus
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The status of this conceptual row. All writable objects in this
            row may be modified at any time."
        ::= { diffServDataPathEntry 4 }
    
    --
    -- Classifiers
    --
    
    diffServClassifier     OBJECT IDENTIFIER ::= { diffServMIBObjects 2 }
    
    --
    -- Classifier Table
    --
    -- The Classifier Table allows multiple classifier elements, of same or
    -- different types, to be used together. A classifier must completely
    -- classify all packets presented to it. This means that all traffic
    -- presented to a classifier must match at least one classifier element
    -- within the classifier, with the classifier element parameters
    -- specified by a filter.
    
    -- If there is ambiguity between classifier elements of different
    -- classifier, classifier linkage order indicates their precedence; the
    -- first classifier in the link is applied to the traffic first.
    
    -- Entries in the classifier element table serves as the anchor for
    -- each classification pattern, defined in filter table entries.  Each
    -- classifier element table entry also specifies the subsequent
    -- downstream Differentiated Services Functional Data Path Element when
    -- the classification pattern is satisfied. Each entry in the
    -- classifier element table describes one branch of the fan-out
    -- characteristic of a classifier indicated in the Informal
    -- Differentiated Services Model section 4.1.  A classifier is composed
    -- of one or more classifier elements.
    
    diffServClfrNextFree OBJECT-TYPE
        SYNTAX        IndexIntegerNextFree
        MAX-ACCESS   read-only
        STATUS        current
        DESCRIPTION
            "This object contains an unused value for diffServClfrId, or a
            zero to indicate that none exist."
        ::= { diffServClassifier 1 }
    
    diffServClfrTable OBJECT-TYPE
        SYNTAX        SEQUENCE OF DiffServClfrEntry
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "This table enumerates all the diffserv classifier functional
            data path elements of this device.  The actual classification
            definitions are defined in diffServClfrElementTable entries
            belonging to each classifier.
    
            An entry in this table, pointed to by a RowPointer specifying an
            instance of diffServClfrStatus, is frequently used as the name
            for a set of classifier elements, which all use the index
            diffServClfrId. Per the semantics of the classifier element
            table, these entries constitute one or more unordered sets of
            tests which may be simultaneously applied to a message to
            classify it.
    
            The primary function of this table is to ensure that the value of
            diffServClfrId is unique before attempting to use it in creating
            a diffServClfrElementEntry. Therefore, the diffServClfrEntry must
            be created on the same SET as the diffServClfrElementEntry, or
            before the diffServClfrElementEntry is created."
        ::= { diffServClassifier 2 }
    
    diffServClfrEntry OBJECT-TYPE
        SYNTAX        DiffServClfrEntry
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "An entry in the classifier table describes a single classifier.
            All classifier elements belonging to the same classifier use the
            classifier's diffServClfrId as part of their index."
        INDEX { diffServClfrId }
        ::= { diffServClfrTable 1 }
    
    DiffServClfrEntry ::= SEQUENCE  {
        diffServClfrId                IndexInteger,
        diffServClfrStorage          StorageType,
        diffServClfrStatus           RowStatus
        }
    
    diffServClfrId OBJECT-TYPE
        SYNTAX        IndexInteger
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "An index that enumerates the classifier entries.  Managers
            should obtain new values for row creation in this table by
            reading diffServClfrNextFree."
        ::= { diffServClfrEntry 1 }
    
    diffServClfrStorage OBJECT-TYPE
        SYNTAX        StorageType
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The storage type for this conceptual row.  Conceptual rows
            having the value 'permanent' need not allow write-access to any
            columnar objects in the row."
        DEFVAL { nonVolatile }
        ::= { diffServClfrEntry 2 }
    
    diffServClfrStatus OBJECT-TYPE
        SYNTAX        RowStatus
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The status of this conceptual row. All writable objects in this
            row may be modified at any time. Setting this variable to
            'destroy' when the MIB contains one or more RowPointers pointing
            to it results in destruction being delayed until the row is no
            longer used."
        ::= { diffServClfrEntry 3 }
    
    --
    -- Classifier Element Table
    --
    diffServClfrElementNextFree OBJECT-TYPE
        SYNTAX        IndexIntegerNextFree
        MAX-ACCESS   read-only
        STATUS        current
        DESCRIPTION
            "This object contains an unused value for diffServClfrElementId,
            or a zero to indicate that none exist."
        ::= { diffServClassifier 3 }
    
    diffServClfrElementTable OBJECT-TYPE
        SYNTAX        SEQUENCE OF DiffServClfrElementEntry
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "The classifier element table enumerates the relationship between
            classification patterns and subsequent downstream Differentiated
            Services Functional Data Path elements.
            diffServClfrElementSpecific points to a filter that specifies the
            classification parameters. A classifier may use filter tables of
            different types together.
    
            One example of a filter table defined in this MIB is
            diffServMultiFieldClfrTable, for IP Multi-Field Classifiers
            (MFCs). Such an entry might identify anything from a single
            micro-flow (an identifiable sub-session packet stream directed
            from one sending transport to the receiving transport or
            transports), or aggregates of those such as the traffic from a
            host, traffic for an application, or traffic between two hosts
            using an application and a given DSCP. The standard Behavior
            Aggregate used in the Differentiated Services Architecture is
            encoded as a degenerate case of such an aggregate - the traffic
            using a particular DSCP value.
    
            Filter tables for other filter types may be defined elsewhere."
        ::= { diffServClassifier 4 }
    
    diffServClfrElementEntry OBJECT-TYPE
        SYNTAX        DiffServClfrElementEntry
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "An entry in the classifier element table describes a single
            element of the classifier."
        INDEX { diffServClfrId, diffServClfrElementId }
        ::= { diffServClfrElementTable 1 }
    
    DiffServClfrElementEntry ::= SEQUENCE  {
        diffServClfrElementId           IndexInteger,
        diffServClfrElementPrecedence  Unsigned32,
        diffServClfrElementNext         RowPointer,
        diffServClfrElementSpecific    RowPointer,
        diffServClfrElementStorage     StorageType,
        diffServClfrElementStatus      RowStatus
        }
    
    diffServClfrElementId OBJECT-TYPE
        SYNTAX        IndexInteger
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "An index that enumerates the Classifier Element entries.
            Managers obtain new values for row creation in this table by
            reading diffServClfrElementNextFree."
        ::= { diffServClfrElementEntry 1 }
    
    diffServClfrElementPrecedence OBJECT-TYPE
        SYNTAX        Unsigned32  (1..4294967295)
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The relative order in which classifier elements are applied:
            higher numbers represent classifier element with higher
            precedence.  Classifier elements with the same order must be
            unambiguous i.e. they must define non-overlapping patterns, and
            are considered to be applied simultaneously to the traffic
            stream. Classifier elements with different order may overlap in
            their filters:  the classifier element with the highest order
            that matches is taken.
    
            On a given interface, there must be a complete classifier in
            place at all times in the ingress direction.  This means one or
            more filters must match any possible pattern. There is no such
            requirement in the egress direction."
        ::= { diffServClfrElementEntry 2 }
    
    diffServClfrElementNext OBJECT-TYPE
        SYNTAX        RowPointer
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "This attribute provides one branch of the fan-out functionality
            of a classifier described in the Informal Differentiated Services
            Model section 4.1.
    
            This selects the next Differentiated Services Functional Data
            Path Element to handle traffic for this data path. This
            RowPointer should point to an instance of one of:
              diffServClfrEntry
              diffServMeterEntry
              diffServActionEntry
              diffServAlgDropEntry
              diffServQEntry
    
            A value of zeroDotZero in this attribute indicates no further
            Differentiated Services treatment is performed on traffic of this
            data path. The use of zeroDotZero is the normal usage for the
            last functional data path element of the current data path.
    
            Setting this to point to a target that does not exist results in
            an inconsistentValue error.  If the row pointed to is removed or
            becomes inactive by other means, the treatment is as if this
            attribute contains a value of zeroDotZero."
    
        ::= { diffServClfrElementEntry 3 }
    
    diffServClfrElementSpecific OBJECT-TYPE
        SYNTAX        RowPointer
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "A pointer to a valid entry in another table, filter table, that
            describes the applicable classification parameters, e.g. an entry
            in diffServMultiFieldClfrTable.
    
            The value zeroDotZero is interpreted to match anything not
            matched by another classifier element - only one such entry may
            exist for each classifier.
    
            Setting this to point to a target that does not exist results in
            an inconsistentValue error.  If the row pointed to is removed or
            becomes inactive by other means, the element is ignored."
        ::= { diffServClfrElementEntry 4 }
    
    diffServClfrElementStorage OBJECT-TYPE
        SYNTAX        StorageType
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The storage type for this conceptual row.  Conceptual rows
            having the value 'permanent' need not allow write-access to any
            columnar objects in the row."
        DEFVAL { nonVolatile }
        ::= { diffServClfrElementEntry 5 }
    
    diffServClfrElementStatus OBJECT-TYPE
        SYNTAX        RowStatus
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The status of this conceptual row. All writable objects in this
            row may be modified at any time. Setting this variable to
            'destroy' when the MIB contains one or more RowPointers pointing
            to it results in destruction being delayed until the row is no
            longer used."
        ::= { diffServClfrElementEntry 6 }
    
    --
    -- IP Multi-field Classification Table
    --
    -- Classification based on six different fields in the IP header.
    -- Functional Data Paths may share definitions by using the same entry.
    --
    
    diffServMultiFieldClfrNextFree OBJECT-TYPE
        SYNTAX        IndexIntegerNextFree
        MAX-ACCESS   read-only
        STATUS        current
        DESCRIPTION
            "This object contains an unused value for
            diffServMultiFieldClfrId, or a zero to indicate that none exist."
        ::= { diffServClassifier 5 }
    
    diffServMultiFieldClfrTable OBJECT-TYPE
        SYNTAX   SEQUENCE OF DiffServMultiFieldClfrEntry
        MAX-ACCESS   not-accessible
        STATUS   current
        DESCRIPTION
            "A table of IP Multi-field Classifier filter entries that a
            system may use to identify IP traffic."
        ::= { diffServClassifier 6 }
    
    diffServMultiFieldClfrEntry OBJECT-TYPE
        SYNTAX        DiffServMultiFieldClfrEntry
        MAX-ACCESS   not-accessible
        STATUS   current
        DESCRIPTION
            "An IP Multi-field Classifier entry describes a single filter."
        INDEX { diffServMultiFieldClfrId }
        ::= { diffServMultiFieldClfrTable 1 }
    
    DiffServMultiFieldClfrEntry ::= SEQUENCE {
        diffServMultiFieldClfrId            IndexInteger,
        diffServMultiFieldClfrAddrType     InetAddressType,
        diffServMultiFieldClfrDstAddr      InetAddress,
        diffServMultiFieldClfrDstPrefixLength InetAddressPrefixLength,
        diffServMultiFieldClfrSrcAddr      InetAddress,
        diffServMultiFieldClfrSrcPrefixLength InetAddressPrefixLength,
        diffServMultiFieldClfrDscp          DscpOrAny,
        diffServMultiFieldClfrFlowId        Unsigned32,
        diffServMultiFieldClfrProtocol     Unsigned32,
        diffServMultiFieldClfrDstL4PortMin InetPortNumber,
        diffServMultiFieldClfrDstL4PortMax InetPortNumber,
        diffServMultiFieldClfrSrcL4PortMin InetPortNumber,
        diffServMultiFieldClfrSrcL4PortMax InetPortNumber,
        diffServMultiFieldClfrStorage      StorageType,
        diffServMultiFieldClfrStatus        RowStatus
        }
    
    diffServMultiFieldClfrId OBJECT-TYPE
        SYNTAX          IndexInteger
        MAX-ACCESS     not-accessible
        STATUS     current
        DESCRIPTION
            "An index that enumerates the MultiField Classifier filter
            entries.  Managers obtain new values for row creation in this
            table by reading diffServMultiFieldClfrNextFree."
    
        ::= { diffServMultiFieldClfrEntry 1 }
    
    diffServMultiFieldClfrAddrType OBJECT-TYPE
        SYNTAX          InetAddressType
        MAX-ACCESS     read-create
        STATUS          current
        DESCRIPTION
            "The type of IP address used by this classifier entry.  While
            other types of addresses are defined in the InetAddressType
            textual convention, and DNS names, a classifier can only look at
            packets on the wire. Therefore, this object is limited to IPv4
            and IPv6 addresses."
        ::= { diffServMultiFieldClfrEntry 2 }
    
    diffServMultiFieldClfrDstAddr OBJECT-TYPE
        SYNTAX          InetAddress
        MAX-ACCESS     read-create
        STATUS          current
        DESCRIPTION
            "The IP address to match against the packet's destination IP
            address. This may not be a DNS name, but may be an IPv4 or IPv6
            prefix.  diffServMultiFieldClfrDstPrefixLength indicates the
            number of bits that are relevant."
        ::= { diffServMultiFieldClfrEntry 3 }
    
    diffServMultiFieldClfrDstPrefixLength OBJECT-TYPE
        SYNTAX          InetAddressPrefixLength
        UNITS           "bits"
        MAX-ACCESS     read-create
        STATUS          current
        DESCRIPTION
            "The length of the CIDR Prefix carried in
            diffServMultiFieldClfrDstAddr. In IPv4 addresses, a length of 0
            indicates a match of any address; a length of 32 indicates a
            match of a single host address, and a length between 0 and 32
            indicates the use of a CIDR Prefix. IPv6 is similar, except that
            prefix lengths range from 0..128."
        DEFVAL          { 0 }
        ::= { diffServMultiFieldClfrEntry 4 }
    
    diffServMultiFieldClfrSrcAddr OBJECT-TYPE
        SYNTAX          InetAddress
        MAX-ACCESS     read-create
        STATUS          current
        DESCRIPTION
            "The IP address to match against the packet's source IP address.
            This may not be a DNS name, but may be an IPv4 or IPv6 prefix.
            diffServMultiFieldClfrSrcPrefixLength indicates the number of
            bits that are relevant."
        ::= { diffServMultiFieldClfrEntry 5 }
    
    diffServMultiFieldClfrSrcPrefixLength OBJECT-TYPE
        SYNTAX          InetAddressPrefixLength
        UNITS           "bits"
        MAX-ACCESS     read-create
        STATUS          current
        DESCRIPTION
            "The length of the CIDR Prefix carried in
            diffServMultiFieldClfrSrcAddr. In IPv4 addresses, a length of 0
            indicates a match of any address; a length of 32 indicates a
            match of a single host address, and a length between 0 and 32
            indicates the use of a CIDR Prefix. IPv6 is similar, except that
            prefix lengths range from 0..128."
        DEFVAL          { 0 }
        ::= { diffServMultiFieldClfrEntry 6 }
    
    diffServMultiFieldClfrDscp OBJECT-TYPE
        SYNTAX          DscpOrAny
        MAX-ACCESS     read-create
        STATUS          current
        DESCRIPTION
            "The value that the DSCP in the packet must have to match this
            entry. A value of -1 indicates that a specific DSCP value has not
            been defined and thus all DSCP values are considered a match."
        DEFVAL          { -1 }
        ::= { diffServMultiFieldClfrEntry 7 }
    
    diffServMultiFieldClfrFlowId OBJECT-TYPE
        SYNTAX          Unsigned32 (0..1048575)
        MAX-ACCESS     read-create
        STATUS          current
        DESCRIPTION
            "The flow identifier in an IPv6 header."
        ::= { diffServMultiFieldClfrEntry 8 }
    
    diffServMultiFieldClfrProtocol OBJECT-TYPE
        SYNTAX          Unsigned32 (0..255)
        MAX-ACCESS     read-create
        STATUS          current
        DESCRIPTION
            "The IP protocol to match against the IPv4 protocol number or the
            IPv6 Next- Header number in the packet. A value of 255 means
            match all.  Note the protocol number of 255 is reserved by IANA,
            and Next-Header number of 0 is used in IPv6."
        DEFVAL          { 255 }
        ::= { diffServMultiFieldClfrEntry 9 }
    
    diffServMultiFieldClfrDstL4PortMin OBJECT-TYPE
        SYNTAX          InetPortNumber
        MAX-ACCESS     read-create
        STATUS          current
        DESCRIPTION
            "The minimum value that the layer-4 destination port number in
            the packet must have in order to match this classifier entry."
        DEFVAL          { 0 }
        ::= { diffServMultiFieldClfrEntry 10 }
    
    diffServMultiFieldClfrDstL4PortMax OBJECT-TYPE
        SYNTAX          InetPortNumber
        MAX-ACCESS     read-create
        STATUS          current
        DESCRIPTION
            "The maximum value that the layer-4 destination port number in
            the packet must have in order to match this classifier entry.
            This value must be equal to or greater than the value specified
            for this entry in diffServMultiFieldClfrDstL4PortMin."
        DEFVAL          { 65535 }
        ::= { diffServMultiFieldClfrEntry 11 }
    
    diffServMultiFieldClfrSrcL4PortMin OBJECT-TYPE
        SYNTAX          InetPortNumber
        MAX-ACCESS     read-create
        STATUS          current
        DESCRIPTION
            "The minimum value that the layer-4 source port number in the
            packet must have in order to match this classifier entry."
        DEFVAL          { 0 }
        ::= { diffServMultiFieldClfrEntry 12 }
    
    diffServMultiFieldClfrSrcL4PortMax OBJECT-TYPE
        SYNTAX          InetPortNumber
        MAX-ACCESS     read-create
        STATUS          current
        DESCRIPTION
            "The maximum value that the layer-4 source port number in the
            packet must have in order to match this classifier entry. This
            value must be equal to or greater than the value specified for
            this entry in diffServMultiFieldClfrSrcL4PortMin."
        DEFVAL          { 65535 }
        ::= { diffServMultiFieldClfrEntry 13 }
    
    diffServMultiFieldClfrStorage OBJECT-TYPE
        SYNTAX        StorageType
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The storage type for this conceptual row.  Conceptual rows
            having the value 'permanent' need not allow write-access to any
            columnar objects in the row."
        DEFVAL { nonVolatile }
        ::= { diffServMultiFieldClfrEntry 14 }
    
    diffServMultiFieldClfrStatus OBJECT-TYPE
        SYNTAX      RowStatus
        MAX-ACCESS  read-create
        STATUS      current
        DESCRIPTION
            "The status of this conceptual row. All writable objects in this
            row may be modified at any time. Setting this variable to
            'destroy' when the MIB contains one or more RowPointers pointing
            to it results in destruction being delayed until the row is no
            longer used."
        ::= { diffServMultiFieldClfrEntry 15 }
    
    --
    -- Meters
    --
    
    diffServMeter           OBJECT IDENTIFIER ::= { diffServMIBObjects 3 }
    
    --
    -- This MIB supports a variety of Meters.  It includes a specific
    -- definition for Token Bucket Meter, which are but one type of
    -- specification. Other metering parameter sets can be defined in other
    -- MIBs.
    
    -- Multiple meter elements may be logically cascaded using their
    -- diffServMeterSucceedNext and diffServMeterFailNext pointers if
    -- required. One example of this might be for an AF PHB implementation
    -- that uses multiple level conformance meters.
    
    -- Cascading of individual meter elements in the MIB is intended to be
    -- functionally equivalent to multiple level conformance determination
    -- of a packet.  The sequential nature of the representation is merely
    -- a notational convenience for this MIB.
    
    -- srTCM meters (RFC 2697) can be specified using two sets of
    -- diffServMeterEntry and diffServTBParamEntry. The first set specifies
    -- the Committed Information Rate and Committed Burst Size
    -- token-bucket.  The second set specifies the Excess Burst Size
    -- token-bucket.
    
    -- trTCM meters (RFC 2698) can be specified using two sets of
    -- diffServMeterEntry and diffServTBParamEntry. The first set specifies
    -- the Committed Information Rate and Committed Burst Size
    -- token-bucket.  The second set specifies the Peak Information Rate
    -- and Peak Burst Size token-bucket.
    
    -- tswTCM meters (RFC 2859) can be specified using two sets of
    -- diffServMeterEntry and diffServTBParamEntry. The first set specifies
    -- the Committed Target Rate token-bucket.  The second set specifies
    -- the Peak Target Rate token-bucket. diffServTBParamInterval in each
    -- token bucket reflects the Average Interval.
    --
    
    diffServMeterNextFree OBJECT-TYPE
        SYNTAX        IndexIntegerNextFree
        MAX-ACCESS   read-only
        STATUS        current
        DESCRIPTION
            "This object contains an unused value for diffServMeterId, or a
            zero to indicate that none exist."
        ::= { diffServMeter 1 }
    
    diffServMeterTable OBJECT-TYPE
        SYNTAX        SEQUENCE OF DiffServMeterEntry
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "This table enumerates specific meters that a system may use to
            police a stream of traffic. The traffic stream to be metered is
            determined by the Differentiated Services Functional Data Path
            Element(s) upstream of the meter i.e. by the object(s) that point
            to each entry in this table.  This may include all traffic on an
            interface.
    
            Specific meter details are to be found in table entry referenced
            by diffServMeterSpecific."
        ::= { diffServMeter 2 }
    
    diffServMeterEntry OBJECT-TYPE
        SYNTAX        DiffServMeterEntry
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "An entry in the meter table describes a single conformance level
            of a meter."
        INDEX { diffServMeterId }
        ::= { diffServMeterTable 1 }
    
    DiffServMeterEntry ::= SEQUENCE  {
        diffServMeterId                 IndexInteger,
        diffServMeterSucceedNext        RowPointer,
        diffServMeterFailNext           RowPointer,
        diffServMeterSpecific           RowPointer,
        diffServMeterStorage            StorageType,
        diffServMeterStatus             RowStatus
        }
    
    diffServMeterId OBJECT-TYPE
        SYNTAX        IndexInteger
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "An index that enumerates the Meter entries.  Managers obtain new
            values for row creation in this table by reading
            diffServMeterNextFree."
        ::= { diffServMeterEntry 1 }
    
    diffServMeterSucceedNext OBJECT-TYPE
        SYNTAX        RowPointer
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "If the traffic does conform, this selects the next
            Differentiated Services Functional Data Path element to handle
            traffic for this data path. This RowPointer should point to an
            instance of one of:
              diffServClfrEntry
              diffServMeterEntry
              diffServActionEntry
              diffServAlgDropEntry
              diffServQEntry
    
            A value of zeroDotZero in this attribute indicates that no
            further Differentiated Services treatment is performed on traffic
            of this data path. The use of zeroDotZero is the normal usage for
            the last functional data path element of the current data path.
    
            Setting this to point to a target that does not exist results in
            an inconsistentValue error.  If the row pointed to is removed or
            becomes inactive by other means, the treatment is as if this
            attribute contains a value of zeroDotZero."
        DEFVAL      { zeroDotZero }
        ::= { diffServMeterEntry 2 }
    
    diffServMeterFailNext OBJECT-TYPE
        SYNTAX        RowPointer
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "If the traffic does not conform, this selects the next
            Differentiated Services Functional Data Path element to handle
            traffic for this data path. This RowPointer should point to an
            instance of one of:
              diffServClfrEntry
              diffServMeterEntry
              diffServActionEntry
              diffServAlgDropEntry
              diffServQEntry
    
            A value of zeroDotZero in this attribute indicates no further
            Differentiated Services treatment is performed on traffic of this
            data path. The use of zeroDotZero is the normal usage for the
            last functional data path element of the current data path.
    
            Setting this to point to a target that does not exist results in
            an inconsistentValue error.  If the row pointed to is removed or
            becomes inactive by other means, the treatment is as if this
            attribute contains a value of zeroDotZero."
        DEFVAL      { zeroDotZero }
        ::= { diffServMeterEntry 3 }
    
    diffServMeterSpecific OBJECT-TYPE
        SYNTAX        RowPointer
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "This indicates the behavior of the meter by pointing to an entry
            containing detailed parameters. Note that entries in that
            specific table must be managed explicitly.
    
            For example, diffServMeterSpecific may point to an entry in
            diffServTBParamTable, which contains an instance of a single set
            of Token Bucket parameters.
    
            Setting this to point to a target that does not exist results in
            an inconsistentValue error.  If the row pointed to is removed or
            becomes inactive by other means, the meter always succeeds."
        ::= { diffServMeterEntry 4 }
    
    diffServMeterStorage OBJECT-TYPE
        SYNTAX        StorageType
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The storage type for this conceptual row.  Conceptual rows
            having the value 'permanent' need not allow write-access to any
            columnar objects in the row."
        DEFVAL { nonVolatile }
        ::= { diffServMeterEntry 5 }
    
    diffServMeterStatus OBJECT-TYPE
        SYNTAX        RowStatus
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The status of this conceptual row. All writable objects in this
            row may be modified at any time. Setting this variable to
            'destroy' when the MIB contains one or more RowPointers pointing
            to it results in destruction being delayed until the row is no
            longer used."
        ::= { diffServMeterEntry 6 }
    
    --
    -- Token Bucket Parameter Table
    --
    
    diffServTBParam         OBJECT IDENTIFIER ::= { diffServMIBObjects 4 }
    
    -- Each entry in the Token Bucket Parameter Table parameterize a single
    -- token bucket.  Multiple token buckets can be used together to
    -- parameterize multiple levels of conformance.
    
    -- Note that an entry in the Token Bucket Parameter Table can be shared
    -- by multiple diffServMeterTable entries.
    --
    
    diffServTBParamNextFree OBJECT-TYPE
        SYNTAX        IndexIntegerNextFree
        MAX-ACCESS   read-only
        STATUS        current
        DESCRIPTION
            "This object contains an unused value for diffServTBParamId, or a
            zero to indicate that none exist."
        ::= { diffServTBParam 1 }
    
    diffServTBParamTable OBJECT-TYPE
        SYNTAX        SEQUENCE OF DiffServTBParamEntry
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "This table enumerates a single set of token bucket meter
            parameters that a system may use to police a stream of traffic.
            Such meters are modeled here as having a single rate and a single
            burst size. Multiple entries are used when multiple rates/burst
            sizes are needed."
        ::= { diffServTBParam 2 }
    
    diffServTBParamEntry OBJECT-TYPE
        SYNTAX        DiffServTBParamEntry
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "An entry that describes a single set of token bucket
            parameters."
        INDEX { diffServTBParamId }
        ::= { diffServTBParamTable 1 }
    
    DiffServTBParamEntry ::= SEQUENCE  {
        diffServTBParamId                IndexInteger,
        diffServTBParamType             AutonomousType,
        diffServTBParamRate             Unsigned32,
        diffServTBParamBurstSize        BurstSize,
        diffServTBParamInterval         Unsigned32,
        diffServTBParamStorage          StorageType,
        diffServTBParamStatus           RowStatus
    }
    
    diffServTBParamId OBJECT-TYPE
        SYNTAX        IndexInteger
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "An index that enumerates the Token Bucket Parameter entries.
            Managers obtain new values for row creation in this table by
            reading diffServTBParamNextFree."
        ::= { diffServTBParamEntry 1 }
    
    diffServTBParamType OBJECT-TYPE
        SYNTAX        AutonomousType
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The Metering algorithm associated with the Token Bucket
            parameters.  zeroDotZero indicates this is unknown.
    
            Standard values for generic algorithms:
            diffServTBParamSimpleTokenBucket, diffServTBParamAvgRate,
            diffServTBParamSrTCMBlind, diffServTBParamSrTCMAware,
            diffServTBParamTrTCMBlind, diffServTBParamTrTCMAware, and
            diffServTBParamTswTCM are specified in this MIB as OBJECT-
            IDENTITYs; additional values may be further specified in other
            MIBs."
        ::= { diffServTBParamEntry 2 }
    
    diffServTBParamRate OBJECT-TYPE
        SYNTAX        Unsigned32  (1..4294967295)
        UNITS         "kilobits per second"
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The token-bucket rate, in kilobits per second (kbps). This
            attribute is used for:
            1. CIR in RFC 2697 for srTCM
            2. CIR and PIR in RFC 2698 for trTCM
            3. CTR and PTR in RFC 2859 for TSWTCM
            4. AverageRate in RFC 3290."
        ::= { diffServTBParamEntry 3 }
    
    diffServTBParamBurstSize OBJECT-TYPE
        SYNTAX        BurstSize
        UNITS         "Bytes"
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The maximum number of bytes in a single transmission burst. This
            attribute is used for:
            1. CBS and EBS in RFC 2697 for srTCM
            2. CBS and PBS in RFC 2698 for trTCM
            3. Burst Size in RFC 3290."
        ::= { diffServTBParamEntry 4 }
    
    diffServTBParamInterval OBJECT-TYPE
        SYNTAX        Unsigned32 (1..4294967295)
        UNITS         "microseconds"
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The time interval used with the token bucket.  For:
            1. Average Rate Meter, the Informal Differentiated Services Model
               section 5.2.1, - Delta.
            2. Simple Token Bucket Meter, the Informal Differentiated
               Services Model section 5.1, - time interval t.
            3. RFC 2859 TSWTCM, - AVG_INTERVAL.
            4. RFC 2697 srTCM, RFC 2698 trTCM, - token bucket update time
               interval."
        ::= { diffServTBParamEntry 5 }
    
    diffServTBParamStorage OBJECT-TYPE
        SYNTAX        StorageType
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The storage type for this conceptual row.  Conceptual rows
            having the value 'permanent' need not allow write-access to any
            columnar objects in the row."
        DEFVAL { nonVolatile }
        ::= { diffServTBParamEntry 6 }
    
    diffServTBParamStatus OBJECT-TYPE
        SYNTAX        RowStatus
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The status of this conceptual row. All writable objects in this
            row may be modified at any time. Setting this variable to
            'destroy' when the MIB contains one or more RowPointers pointing
            to it results in destruction being delayed until the row is no
            longer used."
        ::= { diffServTBParamEntry 7 }
    
    --
    -- OIDs for diffServTBParamType definitions.
    --
    
    diffServTBMeters  OBJECT IDENTIFIER ::= { diffServMIBAdmin 1 }
    
    diffServTBParamSimpleTokenBucket OBJECT-IDENTITY
        STATUS        current
        DESCRIPTION
            "Two Parameter Token Bucket Meter as described in the Informal
            Differentiated Services Model section 5.2.3."
        ::= { diffServTBMeters 1 }
    
    diffServTBParamAvgRate OBJECT-IDENTITY
        STATUS        current
        DESCRIPTION
            "Average Rate Meter as described in the Informal Differentiated
            Services Model section 5.2.1."
        ::= { diffServTBMeters 2 }
    
    diffServTBParamSrTCMBlind OBJECT-IDENTITY
        STATUS        current
        DESCRIPTION
            "Single Rate Three Color Marker Metering as defined by RFC 2697,
            in the `Color Blind' mode as described by the RFC."
        REFERENCE
             "RFC 2697"
        ::= { diffServTBMeters 3 }
    
    diffServTBParamSrTCMAware OBJECT-IDENTITY
        STATUS        current
        DESCRIPTION
            "Single Rate Three Color Marker Metering as defined by RFC 2697,
            in the `Color Aware' mode as described by the RFC."
        REFERENCE
             "RFC 2697"
        ::= { diffServTBMeters 4 }
    
    diffServTBParamTrTCMBlind OBJECT-IDENTITY
        STATUS        current
        DESCRIPTION
            "Two Rate Three Color Marker Metering as defined by RFC 2698, in
            the `Color Blind' mode as described by the RFC."
        REFERENCE
             "RFC 2698"
        ::= { diffServTBMeters 5 }
    
    diffServTBParamTrTCMAware OBJECT-IDENTITY
        STATUS        current
        DESCRIPTION
            "Two Rate Three Color Marker Metering as defined by RFC 2698, in
            the `Color Aware' mode as described by the RFC."
        REFERENCE
             "RFC 2698"
        ::= { diffServTBMeters 6 }
    
    diffServTBParamTswTCM OBJECT-IDENTITY
        STATUS        current
        DESCRIPTION
            "Time Sliding Window Three Color Marker Metering as defined by
            RFC 2859."
        REFERENCE
             "RFC 2859"
        ::= { diffServTBMeters 7 }
    
    --
    -- Actions
    --
    
    diffServAction          OBJECT IDENTIFIER ::= { diffServMIBObjects 5 }
    
    --
    -- The Action Table allows enumeration of the different types of
    -- actions to be applied to a traffic flow.
    --
    
    diffServActionNextFree OBJECT-TYPE
        SYNTAX        IndexIntegerNextFree
        MAX-ACCESS   read-only
        STATUS        current
        DESCRIPTION
            "This object contains an unused value for diffServActionId, or a
            zero to indicate that none exist."
        ::= { diffServAction 1 }
    
    diffServActionTable OBJECT-TYPE
        SYNTAX        SEQUENCE OF DiffServActionEntry
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "The Action Table enumerates actions that can be performed to a
            stream of traffic. Multiple actions can be concatenated. For
            example, traffic exiting from a meter may be counted, marked, and
            potentially dropped before entering a queue.
    
            Specific actions are indicated by diffServActionSpecific which
            points to an entry of a specific action type parameterizing the
            action in detail."
        ::= { diffServAction 2 }
    
    diffServActionEntry OBJECT-TYPE
        SYNTAX        DiffServActionEntry
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "Each entry in the action table allows description of one
            specific action to be applied to traffic."
        INDEX { diffServActionId }
        ::= { diffServActionTable 1 }
    
    DiffServActionEntry ::= SEQUENCE  {
        diffServActionId                  IndexInteger,
        diffServActionInterface          InterfaceIndexOrZero,
        diffServActionNext                RowPointer,
        diffServActionSpecific           RowPointer,
        diffServActionStorage            StorageType,
        diffServActionStatus             RowStatus
        }
    
    diffServActionId OBJECT-TYPE
        SYNTAX        IndexInteger
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "An index that enumerates the Action entries.  Managers obtain
            new values for row creation in this table by reading
            diffServActionNextFree."
        ::= { diffServActionEntry 1 }
    
    diffServActionInterface  OBJECT-TYPE
         SYNTAX         InterfaceIndexOrZero
         MAX-ACCESS    read-create
         STATUS         current
         DESCRIPTION
            "The interface index (value of ifIndex) that this action occurs
            on. This may be derived from the diffServDataPathStartEntry's
            index by extension through the various RowPointers. However, as
            this may be difficult for a network management station, it is
            placed here as well.  If this is indeterminate, the value is
            zero.
    
            This is of especial relevance when reporting the counters which
            may apply to traffic crossing an interface:
               diffServCountActOctets,
               diffServCountActPkts,
               diffServAlgDropOctets,
               diffServAlgDropPkts,
               diffServAlgRandomDropOctets, and
               diffServAlgRandomDropPkts.
    
            It is also especially relevant to the queue and scheduler which
            may be subsequently applied."
         ::= { diffServActionEntry 2 }
    
    diffServActionNext OBJECT-TYPE
        SYNTAX        RowPointer
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "This selects the next Differentiated Services Functional Data
            Path Element to handle traffic for this data path. This
            RowPointer should point to an instance of one of:
              diffServClfrEntry
              diffServMeterEntry
              diffServActionEntry
              diffServAlgDropEntry
              diffServQEntry
    
            A value of zeroDotZero in this attribute indicates no further
            Differentiated Services treatment is performed on traffic of this
            data path. The use of zeroDotZero is the normal usage for the
            last functional data path element of the current data path.
    
            Setting this to point to a target that does not exist results in
            an inconsistentValue error.  If the row pointed to is removed or
            becomes inactive by other means, the treatment is as if this
            attribute contains a value of zeroDotZero."
        DEFVAL      { zeroDotZero }
        ::= { diffServActionEntry 3 }
    
    diffServActionSpecific OBJECT-TYPE
        SYNTAX        RowPointer
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "A pointer to an object instance providing additional information
            for the type of action indicated by this action table entry.
    
            For the standard actions defined by this MIB module, this should
            point to either a diffServDscpMarkActEntry or a
            diffServCountActEntry. For other actions, it may point to an
            object instance defined in some other MIB.
    
            Setting this to point to a target that does not exist results in
            an inconsistentValue error.  If the row pointed to is removed or
            becomes inactive by other means, the Meter should be treated as
            if it were not present.  This may lead to incorrect policy
            behavior."
        ::= { diffServActionEntry 4 }
    
    diffServActionStorage OBJECT-TYPE
        SYNTAX        StorageType
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The storage type for this conceptual row.  Conceptual rows
            having the value 'permanent' need not allow write-access to any
            columnar objects in the row."
        DEFVAL { nonVolatile }
        ::= { diffServActionEntry 5 }
    
    diffServActionStatus OBJECT-TYPE
        SYNTAX        RowStatus
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The status of this conceptual row. All writable objects in this
            row may be modified at any time. Setting this variable to
            'destroy' when the MIB contains one or more RowPointers pointing
            to it results in destruction being delayed until the row is no
            longer used."
        ::= { diffServActionEntry 6 }
    
    -- DSCP Mark Action Table
    --
    -- Rows of this table are pointed to by diffServActionSpecific to
    -- provide detailed parameters specific to the DSCP Mark action.
    --
    -- A single entry in this table can be shared by multiple
    -- diffServActionTable entries.
    --
    
    diffServDscpMarkActTable OBJECT-TYPE
        SYNTAX        SEQUENCE OF DiffServDscpMarkActEntry
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "This table enumerates specific DSCPs used for marking or
            remarking the DSCP field of IP packets. The entries of this table
            may be referenced by a diffServActionSpecific attribute."
        ::= { diffServAction 3 }
    
    diffServDscpMarkActEntry OBJECT-TYPE
        SYNTAX        DiffServDscpMarkActEntry
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "An entry in the DSCP mark action table that describes a single
            DSCP used for marking."
        INDEX { diffServDscpMarkActDscp }
        ::= { diffServDscpMarkActTable 1 }
    
    DiffServDscpMarkActEntry ::= SEQUENCE  {
        diffServDscpMarkActDscp           Dscp
        }
    
    diffServDscpMarkActDscp OBJECT-TYPE
        SYNTAX        Dscp
        MAX-ACCESS   read-only
        STATUS        current
        DESCRIPTION
            "The DSCP that this Action will store into the DSCP field of the
            subject. It is quite possible that the only packets subject to
            this Action are already marked with this DSCP. Note also that
            Differentiated Services processing may result in packet being
            marked on both ingress to a network and on egress from it, and
            that ingress and egress can occur in the same router."
        ::= { diffServDscpMarkActEntry 1 }
    
    --
    -- Count Action Table
    --
    -- Because the MIB structure allows multiple cascading
    -- diffServActionEntry be used to describe multiple actions for a data
    -- path, the counter became an optional action type.  In normal
    -- implementation, either a data path has counters or it does not, as
    -- opposed to being configurable. The management entity may choose to
    -- read the counter or not.  Hence it is recommended for implementation
    -- that have counters to always configure the count action as the first
    -- of multiple actions.
    --
    
    diffServCountActNextFree OBJECT-TYPE
        SYNTAX        IndexIntegerNextFree
        MAX-ACCESS   read-only
        STATUS        current
        DESCRIPTION
            "This object contains an unused value for
            diffServCountActId, or a zero to indicate that none exist."
        ::= { diffServAction 4 }
    
    diffServCountActTable OBJECT-TYPE
        SYNTAX        SEQUENCE OF DiffServCountActEntry
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "This table contains counters for all the traffic passing through
            an action element."
        ::= { diffServAction 5 }
    
    diffServCountActEntry OBJECT-TYPE
        SYNTAX        DiffServCountActEntry
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "An entry in the count action table describes a single set of
            traffic counters."
        INDEX { diffServCountActId }
        ::= { diffServCountActTable 1 }
    
    DiffServCountActEntry ::= SEQUENCE  {
        diffServCountActId            IndexInteger,
        diffServCountActOctets        Counter64,
        diffServCountActPkts          Counter64,
        diffServCountActStorage      StorageType,
        diffServCountActStatus        RowStatus
        }
    
    diffServCountActId OBJECT-TYPE
        SYNTAX        IndexInteger
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "An index that enumerates the Count Action entries.  Managers
            obtain new values for row creation in this table by reading
            diffServCountActNextFree."
        ::= { diffServCountActEntry 1 }
    
    diffServCountActOctets OBJECT-TYPE
        SYNTAX        Counter64
        MAX-ACCESS   read-only
        STATUS        current
        DESCRIPTION
            "The number of octets at the Action data path element.
    
            Discontinuities in the value of this counter can occur at re-
            initialization of the management system and at other times as
            indicated by the value of ifCounterDiscontinuityTime on the
            relevant interface."
        ::= { diffServCountActEntry 2 }
    
    diffServCountActPkts OBJECT-TYPE
        SYNTAX        Counter64
        MAX-ACCESS   read-only
        STATUS        current
        DESCRIPTION
            "The number of packets at the Action data path element.
    
            Discontinuities in the value of this counter can occur at re-
            initialization of the management system and at other times as
            indicated by the value of ifCounterDiscontinuityTime on the
            relevant interface."
        ::= { diffServCountActEntry 3 }
    
    diffServCountActStorage OBJECT-TYPE
        SYNTAX        StorageType
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The storage type for this conceptual row.  Conceptual rows
            having the value 'permanent' need not allow write-access to any
            columnar objects in the row."
        DEFVAL { nonVolatile }
        ::= { diffServCountActEntry 4 }
    
    diffServCountActStatus OBJECT-TYPE
        SYNTAX        RowStatus
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The status of this conceptual row. All writable objects in this
            row may be modified at any time. Setting this variable to
            'destroy' when the MIB contains one or more RowPointers pointing
            to it results in destruction being delayed until the row is no
            longer used."
        ::= { diffServCountActEntry 5 }
    
    --
    -- Algorithmic Drop Table
    --
    
    diffServAlgDrop         OBJECT IDENTIFIER ::= { diffServMIBObjects 6 }
    
    diffServAlgDropNextFree OBJECT-TYPE
        SYNTAX        IndexIntegerNextFree
        MAX-ACCESS   read-only
        STATUS        current
        DESCRIPTION
            "This object contains an unused value for diffServAlgDropId, or a
            zero to indicate that none exist."
        ::= { diffServAlgDrop 1 }
    
    diffServAlgDropTable OBJECT-TYPE
        SYNTAX        SEQUENCE OF DiffServAlgDropEntry
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "The algorithmic drop table contains entries describing an
            element that drops packets according to some algorithm."
        ::= { diffServAlgDrop 2 }
    
    diffServAlgDropEntry OBJECT-TYPE
        SYNTAX        DiffServAlgDropEntry
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "An entry describes a process that drops packets according to
            some algorithm. Further details of the algorithm type are to be
            found in diffServAlgDropType and with more detail parameter entry
            pointed to by diffServAlgDropSpecific when necessary."
        INDEX { diffServAlgDropId }
        ::= { diffServAlgDropTable 1 }
    
    DiffServAlgDropEntry ::= SEQUENCE  {
        diffServAlgDropId                 IndexInteger,
        diffServAlgDropType              INTEGER,
        diffServAlgDropNext              RowPointer,
        diffServAlgDropQMeasure          RowPointer,
        diffServAlgDropQThreshold        Unsigned32,
        diffServAlgDropSpecific          RowPointer,
        diffServAlgDropOctets            Counter64,
        diffServAlgDropPkts              Counter64,
        diffServAlgRandomDropOctets     Counter64,
        diffServAlgRandomDropPkts        Counter64,
        diffServAlgDropStorage           StorageType,
        diffServAlgDropStatus            RowStatus
        }
    
    diffServAlgDropId OBJECT-TYPE
        SYNTAX        IndexInteger
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "An index that enumerates the Algorithmic Dropper entries.
            Managers obtain new values for row creation in this table by
            reading diffServAlgDropNextFree."
        ::= { diffServAlgDropEntry 1 }
    
    diffServAlgDropType OBJECT-TYPE
        SYNTAX        INTEGER {
            other(1),
            tailDrop(2),
            headDrop(3),
            randomDrop(4),
            alwaysDrop(5)
            }
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The type of algorithm used by this dropper. The value other(1)
            requires further specification in some other MIB module.
    
            In the tailDrop(2) algorithm, diffServAlgDropQThreshold
            represents the maximum depth of the queue, pointed to by
            diffServAlgDropQMeasure, beyond which all newly arriving packets
            will be dropped.
    
            In the headDrop(3) algorithm, if a packet arrives when the
            current depth of the queue, pointed to by
            diffServAlgDropQMeasure, is at diffServAlgDropQThreshold, packets
            currently at the head of the queue are dropped to make room for
            the new packet to be enqueued at the tail of the queue.
    
            In the randomDrop(4) algorithm, on packet arrival, an Active
            Queue Management algorithm is executed which may randomly drop a
            packet. This algorithm may be proprietary, and it may drop either
            the arriving packet or another packet in the queue.
            diffServAlgDropSpecific points to a diffServRandomDropEntry that
            describes the algorithm. For this algorithm,
            diffServAlgDropQThreshold is understood to be the absolute
            maximum size of the queue and additional parameters are described
            in diffServRandomDropTable.
    
            The alwaysDrop(5) algorithm is as its name specifies; always
            drop. In this case, the other configuration values in this Entry
            are not meaningful; There is no useful 'next' processing step,
            there is no queue, and parameters describing the queue are not
            useful. Therefore, diffServAlgDropNext, diffServAlgDropMeasure,
            and diffServAlgDropSpecific are all zeroDotZero."
        ::= { diffServAlgDropEntry 2 }
    
    diffServAlgDropNext OBJECT-TYPE
        SYNTAX        RowPointer
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "This selects the next Differentiated Services Functional Data
            Path Element to handle traffic for this data path. This
            RowPointer should point to an instance of one of:
              diffServClfrEntry
              diffServMeterEntry
              diffServActionEntry
              diffServQEntry
    
            A value of zeroDotZero in this attribute indicates no further
            Differentiated Services treatment is performed on traffic of this
            data path. The use of zeroDotZero is the normal usage for the
            last functional data path element of the current data path.
    
            When diffServAlgDropType is alwaysDrop(5), this object is
            ignored.
    
            Setting this to point to a target that does not exist results in
            an inconsistentValue error.  If the row pointed to is removed or
            becomes inactive by other means, the treatment is as if this
            attribute contains a value of zeroDotZero."
        ::= { diffServAlgDropEntry 3 }
    
    diffServAlgDropQMeasure OBJECT-TYPE
        SYNTAX        RowPointer
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "Points to an entry in the diffServQTable to indicate the queue
            that a drop algorithm is to monitor when deciding whether to drop
            a packet. If the row pointed to does not exist, the algorithmic
            dropper element is considered inactive.
    
            Setting this to point to a target that does not exist results in
            an inconsistentValue error.  If the row pointed to is removed or
            becomes inactive by other means, the treatment is as if this
            attribute contains a value of zeroDotZero."
        ::= { diffServAlgDropEntry 4 }
    
    diffServAlgDropQThreshold OBJECT-TYPE
        SYNTAX        Unsigned32  (1..4294967295)
        UNITS         "Bytes"
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "A threshold on the depth in bytes of the queue being measured at
            which a trigger is generated to the dropping algorithm, unless
            diffServAlgDropType is alwaysDrop(5) where this object is
            ignored.
    
            For the tailDrop(2) or headDrop(3) algorithms, this represents
            the depth of the queue, pointed to by diffServAlgDropQMeasure, at
            which the drop action will take place. Other algorithms will need
            to define their own semantics for this threshold."
        ::= { diffServAlgDropEntry 5 }
    
    diffServAlgDropSpecific OBJECT-TYPE
        SYNTAX        RowPointer
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "Points to a table entry that provides further detail regarding a
            drop algorithm.
    
            Entries with diffServAlgDropType equal to other(1) may have this
            point to a table defined in another MIB module.
    
            Entries with diffServAlgDropType equal to randomDrop(4) must have
            this point to an entry in diffServRandomDropTable.
    
            For all other algorithms specified in this MIB, this should take
            the value zeroDotZero.
    
            The diffServAlgDropType is authoritative for the type of the drop
            algorithm and the specific parameters for the drop algorithm
            needs to be evaluated based on the diffServAlgDropType.
    
            Setting this to point to a target that does not exist results in
            an inconsistentValue error.  If the row pointed to is removed or
            becomes inactive by other means, the treatment is as if this
            attribute contains a value of zeroDotZero."
        ::= { diffServAlgDropEntry 6 }
    
    diffServAlgDropOctets OBJECT-TYPE
        SYNTAX        Counter64
        MAX-ACCESS   read-only
        STATUS        current
        DESCRIPTION
            "The number of octets that have been deterministically dropped by
            this drop process.
    
            Discontinuities in the value of this counter can occur at re-
            initialization of the management system and at other times as
            indicated by the value of ifCounterDiscontinuityTime on the
            relevant interface."
        ::= { diffServAlgDropEntry 7 }
    
    diffServAlgDropPkts OBJECT-TYPE
        SYNTAX        Counter64
        MAX-ACCESS   read-only
        STATUS        current
        DESCRIPTION
            "The number of packets that have been deterministically dropped
            by this drop process.
    
            Discontinuities in the value of this counter can occur at re-
            initialization of the management system and at other times as
            indicated by the value of ifCounterDiscontinuityTime on the
            relevant interface."
        ::= { diffServAlgDropEntry 8 }
    
    diffServAlgRandomDropOctets OBJECT-TYPE
        SYNTAX        Counter64
        MAX-ACCESS   read-only
        STATUS        current
        DESCRIPTION
            "The number of octets that have been randomly dropped by this
            drop process.  This counter applies, therefore, only to random
            droppers.
    
            Discontinuities in the value of this counter can occur at re-
            initialization of the management system and at other times as
            indicated by the value of ifCounterDiscontinuityTime on the
            relevant interface."
        ::= { diffServAlgDropEntry 9 }
    
    diffServAlgRandomDropPkts OBJECT-TYPE
        SYNTAX        Counter64
        MAX-ACCESS   read-only
        STATUS        current
        DESCRIPTION
            "The number of packets that have been randomly dropped by this
            drop process. This counter applies, therefore, only to random
            droppers.
    
            Discontinuities in the value of this counter can occur at re-
            initialization of the management system and at other times as
            indicated by the value of ifCounterDiscontinuityTime on the
            relevant interface."
        ::= { diffServAlgDropEntry 10 }
    
    diffServAlgDropStorage OBJECT-TYPE
        SYNTAX        StorageType
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The storage type for this conceptual row.  Conceptual rows
            having the value 'permanent' need not allow write-access to any
            columnar objects in the row."
        DEFVAL { nonVolatile }
        ::= { diffServAlgDropEntry 11 }
    
    diffServAlgDropStatus OBJECT-TYPE
        SYNTAX        RowStatus
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The status of this conceptual row. All writable objects in this
            row may be modified at any time. Setting this variable to
            'destroy' when the MIB contains one or more RowPointers pointing
            to it results in destruction being delayed until the row is no
            longer used."
        ::= { diffServAlgDropEntry 12 }
    
    --
    -- Random Drop Table
    --
    
    diffServRandomDropNextFree OBJECT-TYPE
        SYNTAX        IndexIntegerNextFree
        MAX-ACCESS   read-only
        STATUS        current
        DESCRIPTION
            "This object contains an unused value for diffServRandomDropId,
            or a zero to indicate that none exist."
        ::= { diffServAlgDrop 3 }
    
    diffServRandomDropTable OBJECT-TYPE
        SYNTAX        SEQUENCE OF DiffServRandomDropEntry
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "The random drop table contains entries describing a process that
            drops packets randomly. Entries in this table are pointed to by
            diffServAlgDropSpecific."
        ::= { diffServAlgDrop 4 }
    
    diffServRandomDropEntry OBJECT-TYPE
        SYNTAX        DiffServRandomDropEntry
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "An entry describes a process that drops packets according to a
            random algorithm."
        INDEX { diffServRandomDropId }
        ::= { diffServRandomDropTable 1 }
    
    DiffServRandomDropEntry ::= SEQUENCE  {
        diffServRandomDropId                 IndexInteger,
        diffServRandomDropMinThreshBytes   Unsigned32,
        diffServRandomDropMinThreshPkts    Unsigned32,
        diffServRandomDropMaxThreshBytes   Unsigned32,
        diffServRandomDropMaxThreshPkts    Unsigned32,
        diffServRandomDropProbMax           Unsigned32,
        diffServRandomDropWeight            Unsigned32,
        diffServRandomDropSamplingRate     Unsigned32,
        diffServRandomDropStorage           StorageType,
        diffServRandomDropStatus            RowStatus
        }
    
    diffServRandomDropId OBJECT-TYPE
        SYNTAX        IndexInteger
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "An index that enumerates the Random Drop entries.  Managers
            obtain new values for row creation in this table by reading
            diffServRandomDropNextFree."
        ::= { diffServRandomDropEntry 1 }
    
    diffServRandomDropMinThreshBytes OBJECT-TYPE
        SYNTAX        Unsigned32  (1..4294967295)
        UNITS         "bytes"
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The average queue depth in bytes, beyond which traffic has a
            non-zero probability of being dropped. Changes in this variable
            may or may not be reflected in the reported value of
            diffServRandomDropMinThreshPkts."
        ::= { diffServRandomDropEntry 2 }
    
    diffServRandomDropMinThreshPkts OBJECT-TYPE
        SYNTAX        Unsigned32  (1..4294967295)
        UNITS         "packets"
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The average queue depth in packets, beyond which traffic has a
            non-zero probability of being dropped. Changes in this variable
            may or may not be reflected in the reported value of
            diffServRandomDropMinThreshBytes."
        ::= { diffServRandomDropEntry 3 }
    
    diffServRandomDropMaxThreshBytes OBJECT-TYPE
        SYNTAX        Unsigned32  (1..4294967295)
        UNITS         "bytes"
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The average queue depth beyond which traffic has a probability
            indicated by diffServRandomDropProbMax of being dropped or
            marked. Note that this differs from the physical queue limit,
            which is stored in diffServAlgDropQThreshold. Changes in this
            variable may or may not be reflected in the reported value of
            diffServRandomDropMaxThreshPkts."
        ::= { diffServRandomDropEntry 4 }
    
    diffServRandomDropMaxThreshPkts OBJECT-TYPE
        SYNTAX        Unsigned32  (1..4294967295)
        UNITS         "packets"
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The average queue depth beyond which traffic has a probability
            indicated by diffServRandomDropProbMax of being dropped or
            marked. Note that this differs from the physical queue limit,
            which is stored in diffServAlgDropQThreshold. Changes in this
            variable may or may not be reflected in the reported value of
            diffServRandomDropMaxThreshBytes."
        ::= { diffServRandomDropEntry 5 }
    
    diffServRandomDropProbMax OBJECT-TYPE
        SYNTAX        Unsigned32 (0..1000)
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The worst case random drop probability, expressed in drops per
            thousand packets.
    
            For example, if in the worst case every arriving packet may be
            dropped (100%) for a period, this has the value 1000.
            Alternatively, if in the worst case only one percent (1%) of
            traffic may be dropped, it has the value 10."
       ::= { diffServRandomDropEntry 6 }
    
    diffServRandomDropWeight OBJECT-TYPE
        SYNTAX        Unsigned32 (0..65536)
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The weighting of past history in affecting the Exponentially
            Weighted Moving Average function that calculates the current
            average queue depth.  The equation uses
            diffServRandomDropWeight/65536 as the coefficient for the new
            sample in the equation, and (65536 -
            diffServRandomDropWeight)/65536 as the coefficient of the old
            value.
    
            Implementations may limit the values of diffServRandomDropWeight
            to a subset of the possible range of values, such as powers of
            two. Doing this would facilitate implementation of the
            Exponentially Weighted Moving Average using shift instructions or
            registers."
        ::= { diffServRandomDropEntry 7 }
    
    diffServRandomDropSamplingRate OBJECT-TYPE
        SYNTAX        Unsigned32 (0..1000000)
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The number of times per second the queue is sampled for queue
            average calculation.  A value of zero is used to mean that the
            queue is sampled approximately each time a packet is enqueued (or
            dequeued)."
        ::= { diffServRandomDropEntry 8 }
    
    diffServRandomDropStorage OBJECT-TYPE
        SYNTAX        StorageType
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The storage type for this conceptual row.  Conceptual rows
            having the value 'permanent' need not allow write-access to any
            columnar objects in the row."
        DEFVAL { nonVolatile }
        ::= { diffServRandomDropEntry 9 }
    
    diffServRandomDropStatus OBJECT-TYPE
        SYNTAX        RowStatus
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The status of this conceptual row. All writable objects in this
            row may be modified at any time. Setting this variable to
            'destroy' when the MIB contains one or more RowPointers pointing
            to it results in destruction being delayed until the row is no
            longer used."
        ::= { diffServRandomDropEntry 10 }
    
    --
    -- Queue Table
    --
    
    diffServQueue           OBJECT IDENTIFIER ::= { diffServMIBObjects 7 }
    
    --
    -- An entry of diffServQTable represents a FIFO queue Differentiated
    -- Services Functional Data Path element as described in the Informal
    -- Differentiated Services Model section 7.1.1. Note that the
    -- specification of scheduling parameters for a queue as part of the
    -- input to a scheduler functional data path element as described in
    -- the Informal Differentiated Services Model section 7.1.2. This
    -- allows building of hierarchical queuing/scheduling. A queue
    -- therefore has these attributes:
    --
    -- 1. Which scheduler will service this queue, diffServQNext.
    -- 2. How the scheduler will service this queue, with respect
    --    to all the other queues the same scheduler needs to service,
    --    diffServQMinRate.
    --
    -- Note that upstream Differentiated Services Functional Data Path
    -- elements may point to a shared diffServQTable entry as described
    -- in the Informal Differentiated Services Model section 7.1.1.
    --
    
    diffServQNextFree OBJECT-TYPE
        SYNTAX        IndexIntegerNextFree
        MAX-ACCESS   read-only
        STATUS        current
        DESCRIPTION
            "This object contains an unused value for diffServQId, or a zero
            to indicate that none exist."
        ::= { diffServQueue 1 }
    
    diffServQTable OBJECT-TYPE
        SYNTAX        SEQUENCE OF DiffServQEntry
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "The Queue Table enumerates the individual queues.  Note that the
            MIB models queuing systems as composed of individual queues, one
            per class of traffic, even though they may in fact be structured
            as classes of traffic scheduled using a common calendar queue, or
            in other ways."
        ::= { diffServQueue 2 }
    
    diffServQEntry OBJECT-TYPE
        SYNTAX        DiffServQEntry
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "An entry in the Queue Table describes a single queue or class of
            traffic."
        INDEX { diffServQId }
        ::= { diffServQTable 1 }
    
    DiffServQEntry ::= SEQUENCE  {
        diffServQId                         IndexInteger,
        diffServQNext                      RowPointer,
        diffServQMinRate                   RowPointer,
        diffServQMaxRate                   RowPointer,
        diffServQStorage                   StorageType,
        diffServQStatus                    RowStatus
        }
    
    diffServQId OBJECT-TYPE
        SYNTAX        IndexInteger
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "An index that enumerates the Queue entries.  Managers obtain new
            values for row creation in this table by reading
            diffServQNextFree."
        ::= { diffServQEntry 1 }
    
    diffServQNext OBJECT-TYPE
        SYNTAX        RowPointer
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "This selects the next Differentiated Services Scheduler.  The
            RowPointer must point to a diffServSchedulerEntry.
    
            A value of zeroDotZero in this attribute indicates an incomplete
            diffServQEntry instance. In such a case, the entry has no
            operational effect, since it has no parameters to give it
            meaning.
    
            Setting this to point to a target that does not exist results in
            an inconsistentValue error.  If the row pointed to is removed or
            becomes inactive by other means, the treatment is as if this
            attribute contains a value of zeroDotZero."
        ::= { diffServQEntry 2 }
    
    diffServQMinRate OBJECT-TYPE
        SYNTAX        RowPointer
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "This RowPointer indicates the diffServMinRateEntry that the
            scheduler, pointed to by diffServQNext, should use to service
            this queue.
    
            If the row pointed to is zeroDotZero, the minimum rate and
            priority is unspecified.
    
            Setting this to point to a target that does not exist results in
            an inconsistentValue error.  If the row pointed to is removed or
            becomes inactive by other means, the treatment is as if this
            attribute contains a value of zeroDotZero."
        ::= { diffServQEntry 3 }
    
    diffServQMaxRate OBJECT-TYPE
        SYNTAX        RowPointer
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "This RowPointer indicates the diffServMaxRateEntry that the
            scheduler, pointed to by diffServQNext, should use to service
            this queue.
    
            If the row pointed to is zeroDotZero, the maximum rate is the
            line speed of the interface.
    
            Setting this to point to a target that does not exist results in
            an inconsistentValue error.  If the row pointed to is removed or
            becomes inactive by other means, the treatment is as if this
            attribute contains a value of zeroDotZero."
        ::= { diffServQEntry 4 }
    
    diffServQStorage OBJECT-TYPE
        SYNTAX        StorageType
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The storage type for this conceptual row.  Conceptual rows
            having the value 'permanent' need not allow write-access to any
            columnar objects in the row."
        DEFVAL { nonVolatile }
        ::= { diffServQEntry 5 }
    
    diffServQStatus OBJECT-TYPE
        SYNTAX        RowStatus
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The status of this conceptual row. All writable objects in this
            row may be modified at any time. Setting this variable to
            'destroy' when the MIB contains one or more RowPointers pointing
            to it results in destruction being delayed until the row is no
            longer used."
        ::= { diffServQEntry 6 }
    
    --
    -- Scheduler Table
    --
    
    diffServScheduler      OBJECT IDENTIFIER ::= { diffServMIBObjects 8 }
    
    --
    -- A Scheduler Entry represents a packet scheduler, such as a priority
    -- scheduler or a WFQ scheduler. It provides flexibility for multiple
    -- scheduling algorithms, each servicing multiple queues, to be used on
    -- the same logical/physical interface.
    --
    -- Note that upstream queues or schedulers specify several of the
    -- scheduler's parameters. These must be properly specified if the
    -- scheduler is to behave as expected.
    --
    -- The diffServSchedulerMaxRate attribute specifies the parameters when
    -- a scheduler's output is sent to another scheduler. This is used in
    -- building hierarchical queues or schedulers.
    --
    -- More discussion of the scheduler functional data path element is in
    -- the Informal Differentiated Services Model section 7.1.2.
    --
    
    diffServSchedulerNextFree OBJECT-TYPE
        SYNTAX        IndexIntegerNextFree
        MAX-ACCESS   read-only
        STATUS        current
        DESCRIPTION
            "This object contains an unused value for diffServSchedulerId, or
            a zero to indicate that none exist."
        ::= { diffServScheduler 1 }
    
    diffServSchedulerTable OBJECT-TYPE
        SYNTAX        SEQUENCE OF DiffServSchedulerEntry
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "The Scheduler Table enumerates packet schedulers. Multiple
            scheduling algorithms can be used on a given data path, with each
            algorithm described by one diffServSchedulerEntry."
        ::= { diffServScheduler 2 }
    
    diffServSchedulerEntry OBJECT-TYPE
        SYNTAX        DiffServSchedulerEntry
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "An entry in the Scheduler Table describing a single instance of
            a scheduling algorithm."
        INDEX { diffServSchedulerId }
        ::= { diffServSchedulerTable 1 }
    
    DiffServSchedulerEntry ::= SEQUENCE  {
        diffServSchedulerId                     IndexInteger,
        diffServSchedulerNext                   RowPointer,
        diffServSchedulerMethod                 AutonomousType,
        diffServSchedulerMinRate                RowPointer,
        diffServSchedulerMaxRate                RowPointer,
        diffServSchedulerStorage                StorageType,
        diffServSchedulerStatus                 RowStatus
        }
    
    diffServSchedulerId OBJECT-TYPE
        SYNTAX        IndexInteger
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "An index that enumerates the Scheduler entries.  Managers obtain
            new values for row creation in this table by reading
            diffServSchedulerNextFree."
        ::= { diffServSchedulerEntry 1 }
    
    diffServSchedulerNext OBJECT-TYPE
        SYNTAX        RowPointer
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "This selects the next Differentiated Services Functional Data
            Path Element to handle traffic for this data path. This normally
            is null (zeroDotZero), or points to a diffServSchedulerEntry or a
            diffServQEntry.
    
            However, this RowPointer may also point to an instance of:
              diffServClfrEntry,
              diffServMeterEntry,
              diffServActionEntry,
              diffServAlgDropEntry.
    
            It would point another diffServSchedulerEntry when implementing
            multiple scheduler methods for the same data path, such as having
            one set of queues scheduled by WRR and that group participating
            in a priority scheduling system in which other queues compete
            with it in that way.  It might also point to a second scheduler
            in a hierarchical scheduling system.
    
            If the row pointed to is zeroDotZero, no further Differentiated
            Services treatment is performed on traffic of this data path.
    
            Setting this to point to a target that does not exist results in
            an inconsistentValue error.  If the row pointed to is removed or
            becomes inactive by other means, the treatment is as if this
            attribute contains a value of zeroDotZero."
        DEFVAL        { zeroDotZero }
        ::= { diffServSchedulerEntry 2 }
    
    diffServSchedulerMethod OBJECT-TYPE
        SYNTAX        AutonomousType
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The scheduling algorithm used by this Scheduler. zeroDotZero
            indicates that this is unknown.  Standard values for generic
            algorithms: diffServSchedulerPriority, diffServSchedulerWRR, and
            diffServSchedulerWFQ are specified in this MIB; additional values
            may be further specified in other MIBs."
        ::= { diffServSchedulerEntry 3 }
    
    diffServSchedulerMinRate OBJECT-TYPE
        SYNTAX        RowPointer
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "This RowPointer indicates the entry in diffServMinRateTable
            which indicates the priority or minimum output rate from this
            scheduler. This attribute is used only when there is more than
            one level of scheduler.
    
            When it has the value zeroDotZero, it indicates that no minimum
            rate or priority is imposed.
    
            Setting this to point to a target that does not exist results in
            an inconsistentValue error.  If the row pointed to is removed or
            becomes inactive by other means, the treatment is as if this
            attribute contains a value of zeroDotZero."
        DEFVAL      { zeroDotZero }
        ::= { diffServSchedulerEntry 4 }
    
    diffServSchedulerMaxRate OBJECT-TYPE
        SYNTAX        RowPointer
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "This RowPointer indicates the entry in diffServMaxRateTable
            which indicates the maximum output rate from this scheduler.
            When more than one maximum rate applies (eg, when a multi-rate
            shaper is in view), it points to the first of those rate entries.
            This attribute is used only when there is more than one level of
            scheduler.
    
            When it has the value zeroDotZero, it indicates that no maximum
            rate is imposed.
    
            Setting this to point to a target that does not exist results in
            an inconsistentValue error.  If the row pointed to is removed or
            becomes inactive by other means, the treatment is as if this
            attribute contains a value of zeroDotZero."
        DEFVAL      { zeroDotZero }
        ::= { diffServSchedulerEntry 5 }
    
    diffServSchedulerStorage OBJECT-TYPE
        SYNTAX        StorageType
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The storage type for this conceptual row.  Conceptual rows
            having the value 'permanent' need not allow write-access to any
            columnar objects in the row."
        DEFVAL { nonVolatile }
        ::= { diffServSchedulerEntry 6 }
    
    diffServSchedulerStatus OBJECT-TYPE
        SYNTAX        RowStatus
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The status of this conceptual row. All writable objects in this
            row may be modified at any time. Setting this variable to
            'destroy' when the MIB contains one or more RowPointers pointing
            to it results in destruction being delayed until the row is no
            longer used."
        ::= { diffServSchedulerEntry 7 }
    
    --
    -- OIDs for diffServTBParamType definitions.
    --
    
    diffServSchedulers  OBJECT IDENTIFIER ::= { diffServMIBAdmin 2 }
    
    diffServSchedulerPriority OBJECT-IDENTITY
        STATUS        current
        DESCRIPTION
            "For use with diffServSchedulerMethod to indicate the Priority
            scheduling method.  This is defined as an algorithm in which the
            presence of data in a queue or set of queues absolutely precludes
            dequeue from another queue or set of queues of lower priority.
            Note that attributes from diffServMinRateEntry of the
            queues/schedulers feeding this scheduler are used when
            determining the next packet to schedule."
        ::= { diffServSchedulers 1 }
    
    diffServSchedulerWRR OBJECT-IDENTITY
        STATUS        current
        DESCRIPTION
            "For use with diffServSchedulerMethod to indicate the Weighted
            Round Robin scheduling method, defined as any algorithm in which
            a set of queues are visited in a fixed order, and varying amounts
            of traffic are removed from each queue in turn to implement an
            average output rate by class. Notice attributes from
            diffServMinRateEntry of the queues/schedulers feeding this
            scheduler are used when determining the next packet to schedule."
        ::= { diffServSchedulers 2 }
    
    diffServSchedulerWFQ OBJECT-IDENTITY
        STATUS        current
        DESCRIPTION
            "For use with diffServSchedulerMethod to indicate the Weighted
            Fair Queuing scheduling method, defined as any algorithm in which
            a set of queues are conceptually visited in some order, to
            implement an average output rate by class. Notice attributes from
            diffServMinRateEntry of the queues/schedulers feeding this
            scheduler are used when determining the next packet to schedule."
        ::= { diffServSchedulers 3 }
    
    --
    -- Minimum Rate Parameters Table
    --
    -- The parameters used by a scheduler for its inputs or outputs are
    -- maintained separately from the Queue or Scheduler table entries for
    -- reusability reasons and so that they may be used by both queues and
    -- schedulers.  This follows the approach for separation of data path
    -- elements from parameterization that is used throughout this MIB.
    -- Use of these Minimum Rate Parameter Table entries by Queues and
    -- Schedulers allows the modeling of hierarchical scheduling systems.
    --
    -- Specifically, a Scheduler has one or more inputs and one output.
    -- Any queue feeding a scheduler, or any scheduler which feeds a second
    -- scheduler, might specify a minimum transfer rate by pointing to an
    -- Minimum Rate Parameter Table entry.
    --
    -- The diffServMinRatePriority/Abs/Rel attributes are used as
    -- parameters to the work-conserving portion of a scheduler:
    -- "work-conserving" implies that the scheduler can continue to emit
    -- data as long as there is data available at its input(s).  This has
    -- the effect of guaranteeing a certain priority relative to other
    -- scheduler inputs and/or a certain minimum proportion of the
    -- available output bandwidth. Properly configured, this means a
    -- certain minimum rate, which may be exceeded should traffic be
    -- available should there be spare bandwidth after all other classes
    -- have had opportunities to consume their own minimum rates.
    --
    
    diffServMinRateNextFree OBJECT-TYPE
        SYNTAX        IndexIntegerNextFree
        MAX-ACCESS   read-only
        STATUS        current
        DESCRIPTION
            "This object contains an unused value for diffServMinRateId, or a
            zero to indicate that none exist."
        ::= { diffServScheduler 3 }
    
    diffServMinRateTable OBJECT-TYPE
        SYNTAX        SEQUENCE OF DiffServMinRateEntry
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "The Minimum Rate Parameters Table enumerates individual sets of
            scheduling parameter that can be used/reused by Queues and
            Schedulers."
        ::= { diffServScheduler 4 }
    
    diffServMinRateEntry OBJECT-TYPE
        SYNTAX        DiffServMinRateEntry
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "An entry in the Minimum Rate Parameters Table describes a single
            set of scheduling parameters for use by one or more queues or
            schedulers."
        INDEX { diffServMinRateId }
        ::= { diffServMinRateTable 1 }
    
    DiffServMinRateEntry ::= SEQUENCE  {
        diffServMinRateId               IndexInteger,
        diffServMinRatePriority         Unsigned32,
        diffServMinRateAbsolute         Unsigned32,
        diffServMinRateRelative         Unsigned32,
        diffServMinRateStorage          StorageType,
        diffServMinRateStatus           RowStatus
        }
    
    diffServMinRateId OBJECT-TYPE
        SYNTAX        IndexInteger
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "An index that enumerates the Scheduler Parameter entries.
            Managers obtain new values for row creation in this table by
            reading diffServMinRateNextFree."
        ::= { diffServMinRateEntry 1 }
    
    diffServMinRatePriority OBJECT-TYPE
        SYNTAX        Unsigned32  (1..4294967295)
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The priority of this input to the associated scheduler, relative
            to the scheduler's other inputs. A queue or scheduler with a
            larger numeric value will be served before another with a smaller
            numeric value."
        ::= { diffServMinRateEntry 2 }
    
    diffServMinRateAbsolute OBJECT-TYPE
        SYNTAX        Unsigned32  (1..4294967295)
        UNITS         "kilobits per second"
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The minimum absolute rate, in kilobits/sec, that a downstream
            scheduler element should allocate to this queue. If the value is
            zero, then there is effectively no minimum rate guarantee. If the
            value is non-zero, the scheduler will assure the servicing of
            this queue to at least this rate.
    
            Note that this attribute value and that of
            diffServMinRateRelative are coupled: changes to one will affect
            the value of the other. They are linked by the following
            equation, in that setting one will change the other:
    
              diffServMinRateRelative =
                       (diffServMinRateAbsolute*1000000)/ifSpeed
    
            or, if appropriate:
    
              diffServMinRateRelative = diffServMinRateAbsolute/ifHighSpeed"
        REFERENCE
             "ifSpeed, ifHighSpeed, Interface MIB, RFC 2863"
        ::= { diffServMinRateEntry 3 }
    
    diffServMinRateRelative OBJECT-TYPE
        SYNTAX        Unsigned32  (1..4294967295)
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The minimum rate that a downstream scheduler element should
            allocate to this queue, relative to the maximum rate of the
            interface as reported by ifSpeed or ifHighSpeed, in units of
            1/1000 of 1. If the value is zero, then there is effectively no
            minimum rate guarantee. If the value is non-zero, the scheduler
            will assure the servicing of this queue to at least this rate.
    
            Note that this attribute value and that of
            diffServMinRateAbsolute are coupled: changes to one will affect
            the value of the other. They are linked by the following
            equation, in that setting one will change the other:
    
              diffServMinRateRelative =
                       (diffServMinRateAbsolute*1000000)/ifSpeed
    
            or, if appropriate:
    
              diffServMinRateRelative = diffServMinRateAbsolute/ifHighSpeed"
        REFERENCE
             "ifSpeed, ifHighSpeed, Interface MIB, RFC 2863"
        ::= { diffServMinRateEntry 4 }
    
    diffServMinRateStorage OBJECT-TYPE
        SYNTAX        StorageType
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The storage type for this conceptual row.  Conceptual rows
            having the value 'permanent' need not allow write-access to any
            columnar objects in the row."
        DEFVAL { nonVolatile }
        ::= { diffServMinRateEntry 5 }
    
    diffServMinRateStatus OBJECT-TYPE
        SYNTAX        RowStatus
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The status of this conceptual row. All writable objects in this
            row may be modified at any time. Setting this variable to
            'destroy' when the MIB contains one or more RowPointers pointing
            to it results in destruction being delayed until the row is no
            longer used."
        ::= { diffServMinRateEntry 6 }
    
    --
    -- Maximum Rate Parameter Table
    --
    -- The parameters used by a scheduler for its inputs or outputs are
    -- maintained separately from the Queue or Scheduler table entries for
    -- reusability reasons and so that they may be used by both queues and
    -- schedulers.  This follows the approach for separation of data path
    -- elements from parameterization that is used throughout this MIB.
    -- Use of these Maximum Rate Parameter Table entries by Queues and
    -- Schedulers allows the modeling of hierarchical scheduling systems.
    --
    -- Specifically, a Scheduler has one or more inputs and one output.
    -- Any queue feeding a scheduler, or any scheduler which feeds a second
    -- scheduler, might specify a maximum transfer rate by pointing to a
    -- Maximum Rate Parameter Table entry. Multi-rate shapers, such as a
    
    -- Dual Leaky Bucket algorithm, specify their rates using multiple
    -- Maximum Rate Parameter Entries with the same diffServMaxRateId but
    -- different diffServMaxRateLevels.
    --
    -- The diffServMaxRateLevel/Abs/Rel attributes are used as
    -- parameters to the non-work-conserving portion of a scheduler:
    -- non-work-conserving implies that the scheduler may sometimes not
    -- emit a packet, even if there is data available at its input(s).
    -- This has the effect of limiting the servicing of the queue/scheduler
    -- input or output, in effect performing shaping of the packet stream
    -- passing through the queue/scheduler, as described in the Informal
    -- Differentiated Services Model section 7.2.
    --
    
    diffServMaxRateNextFree OBJECT-TYPE
        SYNTAX        IndexIntegerNextFree
        MAX-ACCESS   read-only
        STATUS        current
        DESCRIPTION
            "This object contains an unused value for diffServMaxRateId, or a
            zero to indicate that none exist."
        ::= { diffServScheduler 5 }
    
    diffServMaxRateTable OBJECT-TYPE
        SYNTAX        SEQUENCE OF DiffServMaxRateEntry
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "The Maximum Rate Parameter Table enumerates individual sets of
            scheduling parameter that can be used/reused by Queues and
            Schedulers."
        ::= { diffServScheduler 6 }
    
    diffServMaxRateEntry OBJECT-TYPE
        SYNTAX        DiffServMaxRateEntry
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "An entry in the Maximum Rate Parameter Table describes a single
            set of scheduling parameters for use by one or more queues or
            schedulers."
        INDEX { diffServMaxRateId, diffServMaxRateLevel }
        ::= { diffServMaxRateTable 1 }
    
    DiffServMaxRateEntry ::= SEQUENCE  {
        diffServMaxRateId               IndexInteger,
        diffServMaxRateLevel            Unsigned32,
        diffServMaxRateAbsolute         Unsigned32,
        diffServMaxRateRelative         Unsigned32,
        diffServMaxRateThreshold        BurstSize,
        diffServMaxRateStorage          StorageType,
        diffServMaxRateStatus           RowStatus
        }
    
    diffServMaxRateId OBJECT-TYPE
        SYNTAX        IndexInteger
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "An index that enumerates the Maximum Rate Parameter entries.
            Managers obtain new values for row creation in this table by
            reading diffServMaxRateNextFree."
        ::= { diffServMaxRateEntry 1 }
    
    diffServMaxRateLevel OBJECT-TYPE
        SYNTAX        Unsigned32 (1..32)
        MAX-ACCESS   not-accessible
        STATUS        current
        DESCRIPTION
            "An index that indicates which level of a multi-rate shaper is
            being given its parameters. A multi-rate shaper has some number
            of rate levels. Frame Relay's dual rate specification refers to a
            'committed' and an 'excess' rate; ATM's dual rate specification
            refers to a 'mean' and a 'peak' rate. This table is generalized
            to support an arbitrary number of rates. The committed or mean
            rate is level 1, the peak rate (if any) is the highest level rate
            configured, and if there are other rates they are distributed in
            monotonically increasing order between them."
        ::= { diffServMaxRateEntry 2 }
    
    diffServMaxRateAbsolute OBJECT-TYPE
        SYNTAX        Unsigned32  (1..4294967295)
        UNITS         "kilobits per second"
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The maximum rate in kilobits/sec that a downstream scheduler
            element should allocate to this queue. If the value is zero, then
            there is effectively no maximum rate limit and that the scheduler
            should attempt to be work conserving for this queue. If the value
            is non-zero, the scheduler will limit the servicing of this queue
            to, at most, this rate in a non-work-conserving manner.
    
            Note that this attribute value and that of
            diffServMaxRateRelative are coupled: changes to one will affect
            the value of the other. They are linked by the following
            equation, in that setting one will change the other:
    
              diffServMaxRateRelative =
                       (diffServMaxRateAbsolute*1000000)/ifSpeed
    
            or, if appropriate:
    
              diffServMaxRateRelative = diffServMaxRateAbsolute/ifHighSpeed"
        REFERENCE
             "ifSpeed, ifHighSpeed, Interface MIB, RFC 2863"
        ::= { diffServMaxRateEntry 3 }
    
    diffServMaxRateRelative OBJECT-TYPE
        SYNTAX        Unsigned32  (1..4294967295)
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The maximum rate that a downstream scheduler element should
            allocate to this queue, relative to the maximum rate of the
            interface as reported by ifSpeed or ifHighSpeed, in units of
            1/1000 of 1. If the value is zero, then there is effectively no
            maximum rate limit and the scheduler should attempt to be work
            conserving for this queue. If the value is non-zero, the
            scheduler will limit the servicing of this queue to, at most,
            this rate in a non-work-conserving manner.
    
            Note that this attribute value and that of
            diffServMaxRateAbsolute are coupled: changes to one will affect
            the value of the other. They are linked by the following
            equation, in that setting one will change the other:
    
              diffServMaxRateRelative =
                       (diffServMaxRateAbsolute*1000000)/ifSpeed
    
            or, if appropriate:
    
              diffServMaxRateRelative = diffServMaxRateAbsolute/ifHighSpeed"
        REFERENCE
             "ifSpeed, ifHighSpeed, Interface MIB, RFC 2863"
        ::= { diffServMaxRateEntry 4 }
    
    diffServMaxRateThreshold OBJECT-TYPE
        SYNTAX        BurstSize
        UNITS         "Bytes"
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The number of bytes of queue depth at which the rate of a
            multi-rate scheduler will increase to the next output rate. In
            the last conceptual row for such a shaper, this threshold is
            ignored and by convention is zero."
        REFERENCE
             "Adaptive rate Shaper, RFC 2963"
        ::= { diffServMaxRateEntry 5 }
    
    diffServMaxRateStorage OBJECT-TYPE
        SYNTAX        StorageType
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The storage type for this conceptual row.  Conceptual rows
            having the value 'permanent' need not allow write-access to any
            columnar objects in the row."
        DEFVAL { nonVolatile }
        ::= { diffServMaxRateEntry 6 }
    
    diffServMaxRateStatus OBJECT-TYPE
        SYNTAX        RowStatus
        MAX-ACCESS   read-create
        STATUS        current
        DESCRIPTION
            "The status of this conceptual row. All writable objects in this
            row may be modified at any time. Setting this variable to
            'destroy' when the MIB contains one or more RowPointers pointing
            to it results in destruction being delayed until the row is no
            longer used."
        ::= { diffServMaxRateEntry 7 }
    
    --
    -- MIB Compliance statements.
    --
    
    diffServMIBCompliances OBJECT IDENTIFIER ::=
                                              { diffServMIBConformance 1 }
    diffServMIBGroups      OBJECT IDENTIFIER ::=
                                              { diffServMIBConformance 2 }
    
    diffServMIBFullCompliance MODULE-COMPLIANCE
        STATUS current
        DESCRIPTION
            "When this MIB is implemented with support for read-create, then
            such an implementation can claim full compliance. Such devices
            can then be both monitored and configured with this MIB."
    
        MODULE IF-MIB -- The interfaces MIB, RFC2863
        MANDATORY-GROUPS {
            ifCounterDiscontinuityGroup
            }
    
        MODULE -- This Module
        MANDATORY-GROUPS {
             diffServMIBDataPathGroup, diffServMIBClfrGroup,
             diffServMIBClfrElementGroup, diffServMIBMultiFieldClfrGroup,
             diffServMIBActionGroup, diffServMIBAlgDropGroup,
             diffServMIBQGroup, diffServMIBSchedulerGroup,
             diffServMIBMaxRateGroup, diffServMIBMinRateGroup,
             diffServMIBCounterGroup
            }
    
        GROUP diffServMIBMeterGroup
        DESCRIPTION
            "This group is mandatory for devices that implement metering
            functions."
    
        GROUP diffServMIBTBParamGroup
        DESCRIPTION
            "This group is mandatory for devices that implement token-bucket
            metering functions."
    
        GROUP diffServMIBDscpMarkActGroup
        DESCRIPTION
            "This group is mandatory for devices that implement DSCP-Marking
            functions."
    
        GROUP diffServMIBRandomDropGroup
        DESCRIPTION
            "This group is mandatory for devices that implement Random Drop
            functions."
    
        OBJECT diffServDataPathStatus
        SYNTAX RowStatus { active(1) }
        WRITE-SYNTAX RowStatus { createAndGo(4), destroy(6) }
        DESCRIPTION
            "Support for createAndWait and notInService is not required."
    
        OBJECT diffServClfrStatus
        SYNTAX RowStatus { active(1) }
        WRITE-SYNTAX RowStatus { createAndGo(4), destroy(6) }
        DESCRIPTION
            "Support for createAndWait and notInService is not required."
    
        OBJECT diffServClfrElementStatus
        SYNTAX RowStatus { active(1) }
        WRITE-SYNTAX RowStatus { createAndGo(4), destroy(6) }
        DESCRIPTION
            "Support for createAndWait and notInService is not required."
    
        OBJECT diffServMultiFieldClfrAddrType
        SYNTAX  InetAddressType { unknown(0), ipv4(1), ipv6(2) }
        DESCRIPTION
            "An implementation is only required to support IPv4 and IPv6
            addresses."
    
        OBJECT diffServMultiFieldClfrDstAddr
        SYNTAX  InetAddress (SIZE(0|4|16))
        DESCRIPTION
            "An implementation is only required to support IPv4 and globally
            unique IPv6 addresses."
    
        OBJECT diffServAlgDropStatus
        SYNTAX RowStatus { active(1) }
        WRITE-SYNTAX RowStatus { createAndGo(4), destroy(6) }
        DESCRIPTION
            "Support for createAndWait and notInService is not required."
    
        OBJECT diffServRandomDropStatus
        SYNTAX RowStatus { active(1) }
        WRITE-SYNTAX RowStatus { createAndGo(4), destroy(6) }
        DESCRIPTION
            "Support for createAndWait and notInService is not required."
    
        OBJECT diffServQStatus
        SYNTAX RowStatus { active(1) }
        WRITE-SYNTAX RowStatus { createAndGo(4), destroy(6) }
        DESCRIPTION
            "Support for createAndWait and notInService is not required."
    
        OBJECT diffServSchedulerStatus
        SYNTAX RowStatus { active(1) }
        WRITE-SYNTAX RowStatus { createAndGo(4), destroy(6) }
        DESCRIPTION
            "Support for createAndWait and notInService is not required."
    
        OBJECT diffServMinRateStatus
        SYNTAX RowStatus { active(1) }
        WRITE-SYNTAX RowStatus { createAndGo(4), destroy(6) }
        DESCRIPTION
            "Support for createAndWait and notInService is not required."
    
        OBJECT diffServMaxRateStatus
        SYNTAX RowStatus { active(1) }
        WRITE-SYNTAX RowStatus { createAndGo(4), destroy(6) }
        DESCRIPTION
            "Support for createAndWait and notInService is not required."
    
        ::= { diffServMIBCompliances 1 }
    
    --
    -- Read-Only Compliance
    --
    
    diffServMIBReadOnlyCompliance MODULE-COMPLIANCE
        STATUS current
        DESCRIPTION
            "When this MIB is implemented without support for read-create
            (i.e. in read-only mode), then such an implementation can claim
            read-only compliance. Such a device can then be monitored but can
            not be configured with this MIB."
    
        MODULE IF-MIB -- The interfaces MIB, RFC2863
        MANDATORY-GROUPS {
            ifCounterDiscontinuityGroup
            }
    
        MODULE -- This Module
        MANDATORY-GROUPS {
            diffServMIBDataPathGroup, diffServMIBClfrGroup,
            diffServMIBClfrElementGroup, diffServMIBMultiFieldClfrGroup,
            diffServMIBActionGroup, diffServMIBAlgDropGroup,
            diffServMIBQGroup, diffServMIBSchedulerGroup,
            diffServMIBMaxRateGroup, diffServMIBMinRateGroup,
            diffServMIBCounterGroup
            }
    
        GROUP diffServMIBMeterGroup
        DESCRIPTION
            "This group is mandatory for devices that implement metering
            functions."
    
        GROUP diffServMIBTBParamGroup
        DESCRIPTION
            "This group is mandatory for devices that implement token-bucket
            metering functions."
    
        GROUP        diffServMIBDscpMarkActGroup
        DESCRIPTION
            "This group is mandatory for devices that implement DSCP-Marking
            functions."
    
        GROUP        diffServMIBRandomDropGroup
        DESCRIPTION
            "This group is mandatory for devices that implement Random Drop
            functions."
    
        OBJECT        diffServDataPathStart
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServDataPathStorage
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServDataPathStatus
        SYNTAX        RowStatus { active(1) }
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required, and active is the only status that
            needs to be supported."
    
        OBJECT        diffServClfrNextFree
        MIN-ACCESS   not-accessible
        DESCRIPTION
            "Object not needed when diffServClfrTable is implemented read-
            only"
    
        OBJECT        diffServClfrStorage
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServClfrStatus
        SYNTAX        RowStatus { active(1) }
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required, and active is the only status that
            needs to be supported."
    
        OBJECT        diffServClfrElementNextFree
        MIN-ACCESS   not-accessible
        DESCRIPTION
            "Object not needed when diffServClfrelementTable is implemented
            read-only"
    
        OBJECT        diffServClfrElementPrecedence
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServClfrElementNext
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServClfrElementSpecific
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServClfrElementStorage
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServClfrElementStatus
        SYNTAX        RowStatus { active(1) }
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required, and active is the only status that
            needs to be supported."
    
        OBJECT        diffServMultiFieldClfrNextFree
        MIN-ACCESS   not-accessible
        DESCRIPTION
            "Object is not needed when diffServMultiFieldClfrTable is
            implemented in read-only mode."
    
        OBJECT        diffServMultiFieldClfrAddrType
        SYNTAX        InetAddressType { unknown(0), ipv4(1), ipv6(2) }
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required. An implementation is only required
            to support IPv4 and IPv6 addresses."
    
        OBJECT        diffServMultiFieldClfrDstAddr
        SYNTAX        InetAddress (SIZE(0|4|16))
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required. An implementation is only required
            to support IPv4 and globally unique IPv6 addresses."
    
        OBJECT        diffServMultiFieldClfrDstPrefixLength
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServMultiFieldClfrSrcAddr
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required. An implementation is only required
            to support IPv4 and globally unique IPv6 addresses."
    
        OBJECT        diffServMultiFieldClfrSrcPrefixLength
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServMultiFieldClfrDscp
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServMultiFieldClfrFlowId
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServMultiFieldClfrProtocol
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServMultiFieldClfrDstL4PortMin
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServMultiFieldClfrDstL4PortMax
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServMultiFieldClfrSrcL4PortMin
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServMultiFieldClfrSrcL4PortMax
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServMultiFieldClfrStorage
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServMultiFieldClfrStatus
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required, createAndWait and notInService
            support is not required."
    
        OBJECT        diffServMeterNextFree
        MIN-ACCESS   not-accessible
        DESCRIPTION
            "Object is not needed when diffServMultiFieldClfrTable is
            implemented in read-only mode."
    
        OBJECT        diffServMeterSucceedNext
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServMeterFailNext
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServMeterSpecific
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServMeterStorage
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServMeterStatus
        SYNTAX        RowStatus { active(1) }
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required, and active is the only status that
            needs to be supported."
    
        OBJECT        diffServTBParamNextFree
        MIN-ACCESS   not-accessible
        DESCRIPTION
            "Object is not needed when diffServTBParamTable is implemented in
            read-only mode."
    
        OBJECT        diffServTBParamType
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServTBParamRate
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServTBParamBurstSize
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServTBParamInterval
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServTBParamStorage
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServTBParamStatus
        SYNTAX        RowStatus { active(1) }
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required, and active is the only status that
            needs to be supported."
    
        OBJECT        diffServActionNextFree
        MIN-ACCESS   not-accessible
        DESCRIPTION
            "Object is not needed when diffServActionTable is implemented in
            read-only mode."
    
        OBJECT        diffServActionInterface
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServActionNext
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServActionSpecific
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServActionStorage
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServActionStatus
        SYNTAX        RowStatus { active(1) }
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required, and active is the only status that
            needs to be supported."
    
        OBJECT        diffServCountActNextFree
        MIN-ACCESS   not-accessible
        DESCRIPTION
            "Object is not needed when diffServCountActTable is implemented
            in read-only mode."
    
        OBJECT        diffServCountActStorage
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServCountActStatus
        SYNTAX        RowStatus { active(1) }
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required, and active is the only status that
            needs to be supported."
    
        OBJECT        diffServAlgDropNextFree
        MIN-ACCESS   not-accessible
        DESCRIPTION
            "Object is not needed when diffServAlgDropTable is implemented in
            read-only mode."
    
        OBJECT        diffServAlgDropType
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServAlgDropNext
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServAlgDropQMeasure
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServAlgDropQThreshold
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServAlgDropSpecific
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServAlgDropStorage
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServAlgDropStatus
        SYNTAX        RowStatus { active(1) }
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required, and active is the only status that
            needs to be supported."
    
        OBJECT        diffServRandomDropNextFree
        MIN-ACCESS   not-accessible
        DESCRIPTION
            "Object is not needed when diffServRandomDropTable is implemented
            in read-only mode."
    
        OBJECT        diffServRandomDropMinThreshBytes
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServRandomDropMinThreshPkts
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServRandomDropMaxThreshBytes
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServRandomDropMaxThreshPkts
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServRandomDropProbMax
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServRandomDropWeight
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServRandomDropSamplingRate
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServRandomDropStorage
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServRandomDropStatus
        SYNTAX        RowStatus { active(1) }
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required, and active is the only status that
            needs to be supported."
    
        OBJECT        diffServQNextFree
        MIN-ACCESS   not-accessible
        DESCRIPTION
            "Object is not needed when diffServQTable is implemented in
            read-only mode."
    
        OBJECT        diffServQNext
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServQMinRate
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServQMaxRate
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServQStorage
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServQStatus
        SYNTAX        RowStatus { active(1) }
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required, and active is the only status that
            needs to be supported."
    
        OBJECT        diffServSchedulerNextFree
        MIN-ACCESS   not-accessible
        DESCRIPTION
            "Object is not needed when diffServSchedulerTable is implemented
            in read-only mode."
    
        OBJECT        diffServSchedulerNext
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServSchedulerMethod
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServSchedulerMinRate
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServSchedulerMaxRate
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServSchedulerStorage
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServSchedulerStatus
        SYNTAX        RowStatus { active(1) }
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required, and active is the only status that
            needs to be supported."
    
        OBJECT        diffServMinRateNextFree
        MIN-ACCESS   not-accessible
        DESCRIPTION
            "Object is not needed when diffServMinRateTable is implemented in
            read-only mode."
    
        OBJECT        diffServMinRatePriority
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServMinRateAbsolute
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServMinRateRelative
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServMinRateStorage
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServMinRateStatus
        SYNTAX        RowStatus { active(1) }
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required, and active is the only status that
            needs to be supported."
    
        OBJECT        diffServMaxRateNextFree
        MIN-ACCESS   not-accessible
        DESCRIPTION
            "Object is not needed when diffServMaxrateTable is implemented in
            read-only mode."
        OBJECT        diffServMaxRateAbsolute
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServMaxRateRelative
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServMaxRateThreshold
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServMaxRateStorage
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required."
    
        OBJECT        diffServMaxRateStatus
        SYNTAX        RowStatus { active(1) }
        MIN-ACCESS   read-only
        DESCRIPTION
            "Write access is not required, and active is the only status that
            needs to be supported."
    
        ::= { diffServMIBCompliances 2 }
    
    diffServMIBDataPathGroup OBJECT-GROUP
        OBJECTS {
            diffServDataPathStart, diffServDataPathStorage,
            diffServDataPathStatus
            }
        STATUS        current
        DESCRIPTION
            "The Data Path Group defines the MIB Objects that describe a
            functional data path."
        ::= { diffServMIBGroups 1 }
    
    diffServMIBClfrGroup OBJECT-GROUP
        OBJECTS {
            diffServClfrNextFree, diffServClfrStorage,
            diffServClfrStatus
            }
        STATUS        current
        DESCRIPTION
            "The Classifier Group defines the MIB Objects that describe the
            list the starts of individual classifiers."
        ::= { diffServMIBGroups 2 }
    
    diffServMIBClfrElementGroup OBJECT-GROUP
        OBJECTS {
            diffServClfrElementNextFree,
            diffServClfrElementPrecedence, diffServClfrElementNext,
            diffServClfrElementSpecific, diffServClfrElementStorage,
            diffServClfrElementStatus
            }
        STATUS        current
        DESCRIPTION
            "The Classifier Element Group defines the MIB Objects that
            describe the classifier elements that make up a generic
            classifier."
        ::= { diffServMIBGroups 3 }
    
    diffServMIBMultiFieldClfrGroup OBJECT-GROUP
        OBJECTS {
            diffServMultiFieldClfrNextFree,
            diffServMultiFieldClfrAddrType,
            diffServMultiFieldClfrDstAddr,
            diffServMultiFieldClfrDstPrefixLength,
            diffServMultiFieldClfrFlowId,
            diffServMultiFieldClfrSrcAddr,
            diffServMultiFieldClfrSrcPrefixLength,
            diffServMultiFieldClfrDscp,
            diffServMultiFieldClfrProtocol,
            diffServMultiFieldClfrDstL4PortMin,
            diffServMultiFieldClfrDstL4PortMax,
            diffServMultiFieldClfrSrcL4PortMin,
            diffServMultiFieldClfrSrcL4PortMax,
            diffServMultiFieldClfrStorage,
            diffServMultiFieldClfrStatus
            }
        STATUS        current
        DESCRIPTION
            "The Multi-field Classifier Group defines the MIB Objects that
            describe a classifier element for matching on various fields of
            an IP and upper-layer protocol header."
        ::= { diffServMIBGroups 4 }
    
    diffServMIBMeterGroup OBJECT-GROUP
        OBJECTS {
            diffServMeterNextFree, diffServMeterSucceedNext,
            diffServMeterFailNext, diffServMeterSpecific,
            diffServMeterStorage, diffServMeterStatus
            }
        STATUS        current
        DESCRIPTION
            "The Meter Group defines the objects used in describing a generic
            meter element."
        ::= { diffServMIBGroups 5 }
    
    diffServMIBTBParamGroup OBJECT-GROUP
        OBJECTS {
            diffServTBParamNextFree, diffServTBParamType,
            diffServTBParamRate, diffServTBParamBurstSize,
            diffServTBParamInterval, diffServTBParamStorage,
            diffServTBParamStatus
            }
        STATUS        current
        DESCRIPTION
            "The Token-Bucket Meter Group defines the objects used in
            describing a token bucket meter element."
        ::= { diffServMIBGroups 6 }
    
    diffServMIBActionGroup OBJECT-GROUP
        OBJECTS {
            diffServActionNextFree, diffServActionNext,
            diffServActionSpecific, diffServActionStorage,
            diffServActionInterface, diffServActionStatus
            }
        STATUS        current
        DESCRIPTION
            "The Action Group defines the objects used in describing a
            generic action element."
        ::= { diffServMIBGroups 7 }
    
    diffServMIBDscpMarkActGroup OBJECT-GROUP
        OBJECTS {
            diffServDscpMarkActDscp
            }
        STATUS        current
        DESCRIPTION
            "The DSCP Mark Action Group defines the objects used in
            describing a DSCP Marking Action element."
        ::= { diffServMIBGroups 8 }
    
    diffServMIBCounterGroup OBJECT-GROUP
        OBJECTS {
            diffServCountActOctets, diffServCountActPkts,
            diffServAlgDropOctets, diffServAlgDropPkts,
            diffServAlgRandomDropOctets, diffServAlgRandomDropPkts,
            diffServCountActStorage, diffServCountActStatus,
            diffServCountActNextFree
            }
        STATUS        current
        DESCRIPTION
            "A collection of objects providing information specific to
            packet-oriented network interfaces."
        ::= { diffServMIBGroups 9 }
    
    diffServMIBAlgDropGroup OBJECT-GROUP
        OBJECTS {
            diffServAlgDropNextFree, diffServAlgDropType,
            diffServAlgDropNext, diffServAlgDropQMeasure,
            diffServAlgDropQThreshold, diffServAlgDropSpecific,
            diffServAlgDropStorage, diffServAlgDropStatus
            }
        STATUS        current
        DESCRIPTION
            "The Algorithmic Drop Group contains the objects that describe
            algorithmic dropper operation and configuration."
        ::= { diffServMIBGroups 10 }
    
    diffServMIBRandomDropGroup OBJECT-GROUP
        OBJECTS {
            diffServRandomDropNextFree,
            diffServRandomDropMinThreshBytes,
            diffServRandomDropMinThreshPkts,
            diffServRandomDropMaxThreshBytes,
            diffServRandomDropMaxThreshPkts,
            diffServRandomDropProbMax,
            diffServRandomDropWeight,
            diffServRandomDropSamplingRate,
            diffServRandomDropStorage,
            diffServRandomDropStatus
            }
        STATUS        current
        DESCRIPTION
            "The Random Drop Group augments the Algorithmic Drop Group for
            random dropper operation and configuration."
        ::= { diffServMIBGroups 11 }
    
    diffServMIBQGroup OBJECT-GROUP
    
        OBJECTS {
            diffServQNextFree, diffServQNext, diffServQMinRate,
            diffServQMaxRate, diffServQStorage, diffServQStatus
            }
        STATUS        current
        DESCRIPTION
            "The Queue Group contains the objects that describe an
            interface's queues."
        ::= { diffServMIBGroups 12 }
    
    diffServMIBSchedulerGroup OBJECT-GROUP
        OBJECTS {
            diffServSchedulerNextFree, diffServSchedulerNext,
            diffServSchedulerMethod, diffServSchedulerMinRate,
            diffServSchedulerMaxRate, diffServSchedulerStorage,
            diffServSchedulerStatus
            }
        STATUS        current
        DESCRIPTION
            "The Scheduler Group contains the objects that describe packet
            schedulers on interfaces."
        ::= { diffServMIBGroups 13 }
    
    diffServMIBMinRateGroup OBJECT-GROUP
        OBJECTS {
            diffServMinRateNextFree, diffServMinRatePriority,
            diffServMinRateAbsolute, diffServMinRateRelative,
            diffServMinRateStorage, diffServMinRateStatus
            }
        STATUS        current
        DESCRIPTION
            "The Minimum Rate Parameter Group contains the objects that
            describe packet schedulers' minimum rate or priority guarantees."
        ::= { diffServMIBGroups 14 }
    
    diffServMIBMaxRateGroup OBJECT-GROUP
        OBJECTS {
            diffServMaxRateNextFree, diffServMaxRateAbsolute,
            diffServMaxRateRelative, diffServMaxRateThreshold,
            diffServMaxRateStorage, diffServMaxRateStatus
            }
        STATUS        current
        DESCRIPTION
            "The Maximum Rate Parameter Group contains the objects that
            describe packet schedulers' maximum rate guarantees."
        ::= { diffServMIBGroups 15 }
    
    END

