Subject: Updated Internet Draft - draft-ietf-disman-express-mib-08.txt

From: Bob Stewart <[email-masked]>
Date: Mon, 22 Feb 1999 09:49:45 -0800 (PST)

Internet Draft   Distributed Management Expression MIB  22 February 1999

                 Distributed Management Expression MIB

                            22 February 1999

                  draft-ietf-disman-express-mib-08.txt

                              Bob Stewart
                          Cisco Systems, Inc.
                           [email-masked]

                          Status of this Memo

This document is an Internet-Draft and is in full conformance with all
provisions of Section 10 of RFC2026.

Internet-Drafts are working documents of the Internet Engineering Task
Force (IETF), its areas, and its working groups.  Note that other groups
may also distribute working documents as Internet-Drafts.

Internet-Drafts are draft documents valid for a maximum of six months
and may be updated, replaced, or obsoleted by other documents at any
time.  It is inappropriate to use Internet- Drafts as reference material
or to cite them other than as ``work in progress.''

The list of current Internet-Drafts can be accessed at
http://www.ietf.org/ietf/1id-abstracts.txt

The list of Internet-Draft Shadow Directories can be accessed at
http://www.ietf.org/shadow.html.

Distribution of this document is unlimited. Please send comments to the
Distributed Management Working Group, <[email-masked]>.

Copyright Notice

Copyright (C) The Internet Society (1999).  All Rights Reserved.

Expires 22 August 1999                                          [Page 1]


Internet Draft   Distributed Management Expression MIB  22 February 1999

1.  Abstract

This memo defines an experimental portion of the Management Information
Base (MIB) for use with network management protocols in the Internet
community.  In particular, it describes managed objects used for
managing expressions of MIB objects.  The results of these expressions
become MIB objects usable like any other MIB object, such as for the
test condition for declaring an event.

The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
"SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this
document are to be interpreted as described in RFC 2119.

2.  The SNMP Management Framework

The SNMP Management Framework presently consists of five major
components:

    o   An overall architecture, described in RFC 2271 [1].

    o   Mechanisms for describing and naming objects and events for the
        purpose of management. The first version of this Structure of
        Management Information (SMI) is called SMIv1 and described in
        RFC 1155 [2], RFC 1212 [3] and RFC 1215 [4]. The second version,
        called SMIv2, is described in RFC 1902 [5], RFC 1903 [6] and RFC
        1904 [7].

    o   Message protocols for transferring management information. The
        first version of the SNMP message protocol is called SNMPv1 and
        described in RFC 1157 [8]. A second version of the SNMP message
        protocol, which is not an Internet standards track protocol, is
        called SNMPv2c and described in RFC 1901 [9] and RFC 1906 [10].
        The third version of the message protocol is called SNMPv3 and
        described in RFC 1906 [10], RFC 2272 [11] and RFC 2274 [12].

    o   Protocol operations for accessing management information. The
        first set of protocol operations and associated PDU formats is
        described in RFC 1157 [8]. A second set of protocol operations
        and associated PDU formats is described in RFC 1905 [13].

    o   A set of fundamental applications described in RFC 2273 [14] and
        the view-based access control mechanism described in RFC 2275
        [15].

Expires 22 August 1999                                          [Page 2]


Internet Draft   Distributed Management Expression MIB  22 February 1999

Managed objects are accessed via a virtual information store, termed the
Management Information Base or MIB.  Objects in the MIB are defined
using the mechanisms defined in the SMI.

This memo specifies a MIB module that is compliant to the SMIv2. A MIB
conforming to the SMIv1 can be produced through the appropriate
translations. The resulting translated MIB must be semantically
equivalent, except where objects or events are omitted because no
translation is possible (use of Counter64). Some machine readable
information in SMIv2 will be converted into textual descriptions in
SMIv1 during the translation process. However, this loss of machine
readable information is not considered to change the semantics of the
MIB.

Expires 22 August 1999                                          [Page 3]


Internet Draft   Distributed Management Expression MIB  22 February 1999

3.  Overview

Users of MIBs often desire MIB objects that MIB designers have not
provided.  Furthermore, such needs vary from one management philosphy to
another.  Rather than fill more and more MIBs with standardized objects,
the Expression MIB supports externally defined expressions of existing
MIB objects.

In the Expression MIB the results of an evaluated expression are MIB
objects that appear no different from any other and are thus usable
anywhere any other MIB object can be used, whether by a management
application directly or via another MIB, including the Expression MIB
itself, forming expressions of expressions.

The Expression MIB is instrumentation for a relatively powerful,
complex, high-level application, considerably different from simple
instrumentation for a communication driver or a protocol.  The MIB is
appropriate in a relatively powerful, resource-rich managed system and
not necessarily in a severely limited environment.

Nevertheless, due to dependencies from the Event MIB [16] and the need
to support as low-end a system as possible, the Expression MIB can be
somewhat stripped down for lower-power, lower-resource implementations,
as described in the Subsets section, below.

Implementation of the Expression MIB in an agent environment led to the
addition of objects that may not have been necessary in an application
environment with complete knowledge of compiled MIB definitions.  This
is appropriate since implementation must be possible within typical
agent environments with some constraints on system resources.

3.1.  Usage

On managed systems that can afford the overhead, the Expression MIB is a
way to create new, customized MIB objects for monitoring.  Although
these can save some network traffic and overhead on management systems,
that is often not a good tradeoff for objects that are simply to be
recorded or displayed.

The primary purpose of the Expression MIB is to provide custom objects
for the Event MIB [16].  A complex expression can evaluate to a rate of
flow or a boolean and thus be subject to testing as an event trigger,
resulting in an SNMP notification.  Without the Expression MIB such
monitoring is limited to the objects in predefined MIBs.  The Expression

Expires 22 August 1999                                          [Page 4]


Internet Draft   Distributed Management Expression MIB  22 February 1999

MIB thus supports powerful tools for the network manager faced with the
monitoring of large, complex systems that can support a significant
level of self management.

3.2.  Operation

Most of the operation of the MIB is described or implied in the object
definitions but a few highlights bear mentioning here.

3.2.1.  Sampling

The MIB supports three types of object sampling for the MIB objects that
make up the expression:  absolute, delta, and changed.

Absolute samples are simply the value of the MIB object at the time it
is sampled.

Absolute samples are not sufficient for expressions of counters, as
counters have meaning only as a delta (difference) from one sample to
the next.  Thus objects may be sampled as deltas.  Delta sampling
requires the application to maintain state for the value at the last
sample, and to do continuous sampling whether or not anyone is looking
at the results.  It thus creates constant overhead.

Changed sampling is a simple fallout of delta sampling where rather than
a difference the result is a boolean indicating whether or not the
object changed value since the last sample.

3.2.2.  Wildcards

Wildcards allow the application of a single expression to multiple
instances of the same MIB object.  The definer of the expression
indicates this choice and provides a partial object identifier, with
some or all of the instance portion left off.  The application then does
the equivalent of GetNext to obtain the object values, thus discovering
the instances.

All wildcarded objects in an expression must have the same semantics for
the missing portion of their object identifiers or the results are
meaningless because of combining information where the matching of the
wildcarded instance is accidental rather than meaninful.

Expires 22 August 1999                                          [Page 5]


Internet Draft   Distributed Management Expression MIB  22 February 1999

The expression can be evaluated only for those instances where all the
objects in the expression are available with the same value for the
wildcarded portion of the instance.

3.2.3.  Evaluation

There are two important aspects of evaluation that may not be obvious:
what objects and when.

What objects get used in the evaluation depends on the type of request
and whether or not the expression contains wildcarded objects.  If the
request was a Get, that locks down the instances to be used.  If the
request was a GetNext or GetBulk, the application must work its way up
to the next full set of objects for the expression.

Evaluation of expressions happens at two possible times, depending on
the sampling.

For fully absolute expressions evaluation occurs on demand, when a
requester attempts to read a value.  In this case all requesters get a
freshly calculated value.

For expressions with delta or change values, evaluation goes on
continuously, every sample period.  In this case requesters get the
value as of the last sample period.  For any given sample period of a
given expression, only those instances exist that provided a full set of
object values.  No obsolete values are kept from one sample period to
the next.

3.2.4.  Value Identification

Values resulting from expression evaluation are identified with a
combination of the object identifier (OID) for the data type from
expValueTable (such as expValueCounter32Val), the expression name, and
an OID fragment.

The OID fragment is not an entire OID beginning with iso.dod.org
(1.3.6).  Rather it begins with 0.0.  The remainder is either another 0
when there is no wildcarding or the instance that satisfied the wildcard
if there is.

Expires 22 August 1999                                          [Page 6]


Internet Draft   Distributed Management Expression MIB  22 February 1999

3.3.  Subsets

To pare down the Expression MIBs complexity and use of resources an
implementor can leave out various parts.

3.3.1.  No Wildcards

Leaving out wildcarding significantly reduces the complexity of
retrieving values to evaluate expressions and the processing required to
do so.  Such an implementation would allow expressions made up of
individual MIB objects but would not be suitable for expressions applied
across large tables as each instance in the table would require a
separate expression definition.

Furthermore it would not be suitable for tables with arbitrary, dynamic
instances, as expressions definitions could not predict what instance
values to use.

An implementation without wildcards might be useful for a self-managing
system with small table or few dynamic instances, or one that can do
calculations only for a few key objects.

3.3.2.  No Deltas

Leaving out delta processing significantly reduces state that must be
kept and the burden of ongoing processing even when no one is looking at
the results.  Unfortunately it also makes expressions on counters
unusable, as counters have meaning only as deltas.

An implementation without deltas might be useful for a severly limited,
self-managing system that has no need for expressions or events on
counters.  Although conceivable, such systems would be rare.

3.3.3.  One Object Expressions

Limiting expressions to a single object with no operators reduces the
complexity of parsing expressions, retrieving multiple objects per
expression, and doing expression evaluation.  It would thus provide no
ability effectively to define new MIB objects.

An implementation limited to one object expressions with deltas is the
least implementation of the Expression MIB that supports the

Expires 22 August 1999                                          [Page 7]


Internet Draft   Distributed Management Expression MIB  22 February 1999

thresholding abilities of the Event MIB [16].

3.4.  Structure

The MIB has the following sections:

    o   Resource -- management of the MIB's use of system resources.

    o   Definition -- definition of expressions.

    o   Value -- values of evaluated expressions.

3.4.1.  Resource

The resource section has objects to manage resource usage by wildcarded
delta expressions, a potential major consumer of CPU and memory.

3.4.2.  Definition

The definition section contains the tables that define expressions.

The expression table, indexed by expression name, contains those
parameters that apply to the entire expression, such as the expression
itself, the data type of the result, and the sampling interval if it
contains delta or change values.

The object table, indexed by expression name and object index within
each expression, contains the parameters that apply to the individual
objects that go into the expression, including the object identifier,
sample type, discontinuity indicator, and such.

3.4.3.  Value

The value section contains the values of evaluated expressions.

The value table, indexed by expression name and instance fragment
contains a "discriminated union" of evaluated expression results.  For a
given expression only one of the columns is instantiated, depending on
the result data type for the expression.  The instance fragment is a
constant or the final section of object identifier that filled in a
wildcard.

Expires 22 August 1999                                          [Page 8]


Internet Draft   Distributed Management Expression MIB  22 February 1999

3.5.  Examples

The examples refer to tables and objects defined below in the MIB
itself.  They may well make more sense after reading those definitions.

3.5.1.  Wildcarding

An expression may use wildcarded MIB objects that result in multiple
values for the expression.  To specify a wildcarded MIB object a
management application leaves off part or all of the instance portion of
the object identifier, and sets expObjectWildcard to true(1) for that
object.  For our example we'll use a counter of total blessings from a
table of people.  Another table, indexed by town and person has
blessings just from that town.

So the index clauses are:

    personEntry OBJECT-TYPE
    ...
    INDEX { personIndex }

And:

    townPersonEntry OBJECT-TYPE
    ...
    INDEX { townIndex, personIndex }

In our friendly application we may have entered our expression as:

    100 * townPersonBlessings.976.* / personBlessings.*

What goes in expExpression is:

    100*$1/$2

For example purposes we'll use some slightly far-fetched OIDs, but the
weirdity won't matter.  The People MIB is 1.3.6.1.99.7 and the Town MIB
is 1.3.6.1.99.11, so for our two counters the OIDs are:

    personBlessings             1.3.6.1.99.7.1.3.1.4
    townPersonBlessings 1.3.6.1.99.11.1.2.1.9

The rule for wildcards is that all the wildcarded parts have to match
exactly.  In this case that means we have to hardwire the town and only

Expires 22 August 1999                                          [Page 9]


Internet Draft   Distributed Management Expression MIB  22 February 1999

the personIndex can be wildcarded.  So our values for expObjectID are:

    1.3.6.1.99.7.1.3.1.4
    1.3.6.1.99.11.1.2.1.9.976

We're hardwired to townIndex 976 and personIndex is allowed to vary.

The value of expExpressionPrefix can be either of those two counter OIDs
(including the instance fragment in the second case), since either of
them takes you to a MIB definition where you can look at the INDEX
clause and figure out what's been left off.  What's been left off
doesn't have to work out to be the same object, but it does have to work
out to be the same values (semantics) for the result to make sense.
Note that the agent can not typically check such semantics and if given
nonsense will return nonsense.

If we have people numbered 6, 19, and 42 in town number 976, the
successive values of expValueInstance will be:

    0.0.6
    0.0.19
    0.0.42

So there will be three values in expValueTable, with those OIDs as the
expValueInstance part of their indexing.

3.5.2.  Calculation and Conditional

The following formula for line utilization is adapted from [17].

    utilization = (ifInOctets + ifOutOctets) * 800 / seconds / ifSpeed

The expression results in the percentage line utilization per second.
The total octets are multipled by 8 to get bits and 100 to scale up the
percentage as an integer.

The following Expression MIB object values implement this as an
expression for all ifIndexes that directly represent actual hardware.
Since the octet counters are Counter32 values, they must be delta
sampled to be meaningful.  The sample period is 6 seconds but for
accuracy and independence is calculated as a delta of sysUpTime.

The expObjectTable entry for ifInOctets has an expObjectConditional that

Expires 22 August 1999                                         [Page 10]


Internet Draft   Distributed Management Expression MIB  22 February 1999

checks for being a hardware interface.  Only one object in the
expression needs that check associated, since it applies to the whole
expression.  Since ifConnectorPresent is a TruthValue with values of 1
or 2 rather than 0 and non-zero, it must also be in an expression rather
than used directly for the conditional.

The interface-specific discontinuity indicator is supplied only for
ifInOctets since invalidating that sample will invalidate an attempt at
evaluation, effectively invalidating ifOutOctets as well (correctly,
because it has the same indicator).

For notational clarity a string in quotes as part of the object instance
indicates the value that would actually be one subidentifier per byte.

Also for clarity OIDs are expressed as the object descriptor and
instance.  In fact they must be supplied numerically, with all
subidentifiers in place before the part for the particular object and
instance.

What the user must set in expExpressionTable:

expExpression.4."hard"                  = "$1==1"
expExpressionValueType.4."hard"         = unsigned32
expExpressionRowStatus.4."hard"         = 'active'

expExpression.4."util"                  = "($1+$2)*800/$4/$3"
expExpressionValueType.4."util"         = integer32
expExpressionDeltaInterval.4."util"     = 6
expExpressionRowStatus.4."util"         = 'active'

What the user must set in expObjectTable:

expObjectID.4."hard".1                  = ifConnectorPresent
expObjectWildcard.4."hard".1            = 'true'
expObjectSampleType.4."hard".1          = 'absoluteValue'
expObjectRowStatus.4."hard".1           = 'active'

expObjectID.4."util".1                  = ifInOctets
expObjectWildcard.4."util".1            = 'true'
expObjectSampleType.4."util".1          = 'deltaValue'
expObjectConditional.4."util".1         =
expValueUnsigned32Val.4."hard".0.0
expObjectConditionalWildcard.4."util".1 = 'true'
expObjectDiscontinuityID.4."util".1     = ifCounterDiscontinuityTime
expObjectDiscontinuityIDWildcard.4."util".1     = 'true'

Expires 22 August 1999                                         [Page 11]


Internet Draft   Distributed Management Expression MIB  22 February 1999

expObjectRowStatus.4."util".1           = 'active'

expObjectID.4."util".2                  = ifOutOctets
expObjectWildcard.4."util".2            = 'true'
expObjectSampleType.4."util".2          = 'deltaValue'
expObjectRowStatus.4."util".2           = 'active'

expObjectID.4."util".3                  = ifSpeed
expObjectWildcard.4."util".3            = 'true'
expObjectSampleType.4."util".3          = 'absoluteValue'
expObjectRowStatus.4."util".3           = 'active'

expObjectID.4."util".4                  = sysUpTime.0
expObjectWildcard.4."util".4            = 'false'
expObjectSampleType.4."util".4          = 'deltaValue'
expObjectRowStatus.4."util".4           = 'active'

These settings will result in populating one column of expValueTable:

expValueInteger32Val.4."util".0.0.?

The subidentifier represented by "?" above represents one subidentifier
that takes on a value of ifIndex and identifies a row for each ifIndex
value where ifConnectorPresent is 'true' and the interface was present
for two samples to provide a delta.

This value could in turn be used as an event threshold [16] to watch for
overutilization of all hardware network connections.

Expires 22 August 1999                                         [Page 12]


Internet Draft   Distributed Management Expression MIB  22 February 1999

4.  Definitions

DISMAN-EXPRESSION-MIB DEFINITIONS ::= BEGIN

IMPORTS
    MODULE-IDENTITY, OBJECT-TYPE,
    Integer32, Gauge32, Unsigned32,
    Counter32, Counter64, IpAddress,
    TimeTicks, experimental             FROM SNMPv2-SMI
    RowStatus, TruthValue, TimeStamp    FROM SNMPv2-TC
    OwnerString                         FROM IF-MIB
    sysUpTime                           FROM SNMPv2-MIB
    SnmpAdminString                     FROM SNMP-FRAMEWORK-MIB
    MODULE-COMPLIANCE, OBJECT-GROUP     FROM SNMPv2-CONF;

dismanExpressionMIB MODULE-IDENTITY
    LAST-UPDATED "9901221700Z"
    ORGANIZATION "IETF Distributed Management Working Group"
    CONTACT-INFO "Bob Stewart
                  Cisco Systems, Inc.
                  170 West Tasman Drive,
                  San Jose CA 95134-1706.
                  Phone: +1 408 526 4527
                  Email: [email-masked]"
    DESCRIPTION
        "The MIB module for defining expressions of MIB objects for
        management purposes."
    ::= { experimental xx }

dismanExpressionMIBObjects OBJECT IDENTIFIER ::= { dismanExpressionMIB 1 }

expResource     OBJECT IDENTIFIER ::= { dismanExpressionMIBObjects 1 }
expDefine       OBJECT IDENTIFIER ::= { dismanExpressionMIBObjects 2 }
expValue        OBJECT IDENTIFIER ::= { dismanExpressionMIBObjects 3 }

--
-- Resource Control
--

expResourceDeltaMinimum OBJECT-TYPE
    SYNTAX      Integer32 (-1 | 1..600)
    UNITS       "seconds"
    MAX-ACCESS  read-write

Expires 22 August 1999                                         [Page 13]


Internet Draft   Distributed Management Expression MIB  22 February 1999

    STATUS      current
    DESCRIPTION
        "The minimum expExpressionDeltaInterval this system will
        accept.  A system may use the larger values of this minimum
        to lessen the impact of constantly computing deltas.

        The value -1 indicates this system will not accept
        deltaValue as a value for expObjectSampleType.

        Unless explicitly resource limited, a system's value for
        this object should be 1.

        Changing this value will not invalidate an existing setting
        of expObjectSampleType."
    ::= { expResource 1 }

expResourceDeltaWildcardInstanceMaximum OBJECT-TYPE
    SYNTAX      Unsigned32
    UNITS       "instances"
    MAX-ACCESS  read-write
    STATUS      current
    DESCRIPTION
        "The maximum number of dynamic instance entries this system
        will support for wildcarded delta objects in expressions.
        These are the entries that maintain state, one for each
        instance of each deltaValue object for each value of an
        expression.  That is, for a given delta expression, the number
        of such instances is the number of values that meet all criteria
        to exist times the number of delta values in the expression.

        A value of 0 indicates no preset limit, that is, the limit
        is dynamic based on system operation and resources.

        Unless explicitly resource limited, a system's value for
        this object should be 0.

        Changing this value will not eliminate or inhibit existing delta
        wildcard instance objects but will prevent the creation of more
        such objects.

        An attempt to allocate beyond the limit results in expErrorCode
        being tooManyWildcardValues for that evalutation attempt."
    ::= { expResource 2 }

expResourceDeltaWildcardInstances OBJECT-TYPE

Expires 22 August 1999                                         [Page 14]


Internet Draft   Distributed Management Expression MIB  22 February 1999

    SYNTAX      Gauge32
    UNITS       "instances"
    MAX-ACCESS  read-only
    STATUS      current
    DESCRIPTION
        "The number of currently active instance entries as
        defined for expResourceDeltaWildcardInstanceMaximum."
    ::= { expResource 3 }

expResourceDeltaWildcardInstancesHigh OBJECT-TYPE
    SYNTAX      Gauge32
    UNITS       "instances"
    MAX-ACCESS  read-only
    STATUS      current
    DESCRIPTION
        "The highest value of expResourceDeltaWildcardInstances
        that has occurred since initialization of the management
        system."
    ::= { expResource 4 }

expResourceDeltaWildcardInstanceResourceLacks OBJECT-TYPE
    SYNTAX      Counter32
    UNITS       "instances"
    MAX-ACCESS  read-only
    STATUS      current
    DESCRIPTION
        "The number of times this system could not evaluate an
        expression because that would have created a value instance in
        excess of expResourceDeltaWildcardInstanceMaximum."
    ::= { expResource 5 }

--
-- Definition
--
-- Expression Definition Table
--

expExpressionTable OBJECT-TYPE
    SYNTAX      SEQUENCE OF ExpExpressionEntry
    MAX-ACCESS  not-accessible
    STATUS      current
    DESCRIPTION
        "A table of expression definitions."
    ::= { expDefine 1 }

Expires 22 August 1999                                         [Page 15]


Internet Draft   Distributed Management Expression MIB  22 February 1999

expExpressionEntry OBJECT-TYPE
    SYNTAX      ExpExpressionEntry
    MAX-ACCESS  not-accessible
    STATUS      current
    DESCRIPTION
        "Information about a single expression.  New expressions
        can be created using expExpressionRowStatus.

        To create an expression first create the named entry in this
        table.  Then use expExpressionName to populate expObjectTable.
        For expression evaluation to succeed all related entries in
        expExpressionTable and expObjectTable must be 'active'.  If
        these conditions are not met the corresponding values in
        expValue simply are not instantiated.

        Deleting an entry deletes all related entries in expObjectTable
        and expErrorTable.

        Because of the relationships among the multiple tables for an
        expression (expExpressionTable, expObjectTable, and
        expValueTable) and the SNMP rules for independence in setting
        object values, it is necessary to do final error checking when
        an expression is evaluated, that is, when one of its instances
        in expValueTable is read or a delta interval expires.  Earlier
        checking need not be done and an implementation may not impose
        any ordering on the creation of objects related to an
        expression.

        To maintain security of MIB information, when creating a new row in
        this table, the managed system must record the security credentials
        of the requester.  These security credentials are the parameters
        necessary as inputs to isAccessAllowed from the Architecture for
        Describing SNMP Management Frameworks.  When obtaining the objects
        that make up the expression, the system must (conceptually) use
        isAccessAllowed to ensure that it does not violate security.

        If the subsequent expression includes objects with
        expObjectSampleType 'deltaValue' the evaluation of that expression
        takes place under the security credentials of the creator of its
        expExpressionEntry.

        Values of read-write objects in this table may be changed
        at any time."
    INDEX       { expOwner, expExpressionName }
    ::= { expExpressionTable 1 }

Expires 22 August 1999                                         [Page 16]


Internet Draft   Distributed Management Expression MIB  22 February 1999

ExpExpressionEntry ::= SEQUENCE {
    expOwner                     SnmpAdminString,
    expExpressionName            SnmpAdminString,
    expExpression                OCTET STRING,
    expExpressionValueType       INTEGER,
    expExpressionComment         SnmpAdminString,
    expExpressionDeltaInterval   Integer32,
    expExpressionPrefix          OBJECT IDENTIFIER,
    expExpressionErrors          Counter32,
    expExpressionOwner           OwnerString,
    expExpressionEntryStatus     RowStatus
}

expOwner OBJECT-TYPE
   SYNTAX      SnmpAdminString (SIZE(0..32))
   MAX-ACCESS  not-accessible
   STATUS      current
   DESCRIPTION
        "The owner of this entry. The exact semantics of this
        string are subject to the security policy defined by the
        security administrator."
    ::= { expExpressionEntry 1 }

expExpressionName OBJECT-TYPE
    SYNTAX      SnmpAdminString (SIZE (1..32))
    MAX-ACCESS  not-accessible
    STATUS      current
    DESCRIPTION
        "The name of the expression.  This is locally unique, within
        the scope of an expOwner.
    ::= { expExpressionEntry 2 }

expExpression OBJECT-TYPE
    SYNTAX      OCTET STRING (SIZE (1..1024))
    MAX-ACCESS  read-create
    STATUS      current
    DESCRIPTION
        "The expression to be evaluated.  This object is the same
        as a DisplayString (RFC 1903) except for its maximum length.

        In a minimal implementation expressions may be limited to a
        single object with no operators.

        Except for the variable names the expression is in ANSI C
        syntax.  Only the subset of ANSI C operators and functions

Expires 22 August 1999                                         [Page 17]


Internet Draft   Distributed Management Expression MIB  22 February 1999

        listed here is allowed.

        Variables are expressed as a dollar sign ('$') and an
        integer that corresponds to an expObjectIndex.  An
        example of a valid expression is:

                ($1-$5)*100

        Expressions may not be recursive, that is although an expression
        may use the results of another expression, it may not contain
        any variable that is directly or indirectly a result of its own
        evaluation.

        The only allowed operators are:

                ( )
                - (unary)
                + - * / %
                & | ^ << >> ~
                ! && || == != > >= < <=

        Note the parentheses are included for parenthesizing the
        expression, not for casting data types.

        The only constant types defined are:

                int (32-bit signed)
                long (64-bit signed)
                unsigned int
                unsigned long
                hexadecimal
                character
                string
                oid

        The default type for a positive integer is int unless it is too
        large in which case it is long.

        All but oid are as defined for ANSI C.  Note that a
        hexadecimal constant may end up as a scalar or an array of
        8-bit integers.  A string constant is enclosed in double
        quotes and may contain back-slashed individual characters
        as in ANSI C.

        An oid constant comprises 32-bit, unsigned integers and at

Expires 22 August 1999                                         [Page 18]


Internet Draft   Distributed Management Expression MIB  22 February 1999

        least one period, for example:

                0.
                .0
                1.3.6.1

        No additional leading or trailing subidentifiers are automatically
        added to an OID constant.  The constant is taken as expressed.

        Integer-typed objects are treated as 32- or 64-bit, signed
        or unsigned integers, as appropriate.  The results of
        mixing them are as for ANSI C, including the type of the
        result.  Note that a 32-bit value is thus promoted to 64 bits
        only in an operation with a 64-bit value.  There is no
        provision for larger values to handle overflow.

        Relative to SNMP data types, a resulting value becomes
        unsigned when calculating it uses any unsigned value,
        including a counter.  To force the final value to be of
        data type counter the expression must explicitly use the
        counter32() or counter64() function (defined below).

        OCTET STRINGS and OBJECT IDENTIFIERs are treated as 1-based
        arrays of unsigned 8-bit integers and unsigned 32-bit
        integers, respectively.

        IpAddresses are treated as 32-bit, unsigned integers in
        network byte order, that is, the hex version of 255.0.0.0 is
        0xff000000.

        Conditional expressions result in a 32-bit, unsigned integer
        of value 0 for false or 1 for true. When an arbitrary value
        is used as a boolean 0 is false and non-zero is true.

        Rules for the resulting data type from an operation, based on
        the operator:

        For << and >> the result is the same as the left hand operand.

        For &&, ||, ==, !=, <, <=, >, and >= the result is always
        Unsigned32.

        For unary - the result is always Integer32.

        For +, -, *, /, %, &, |, and ^ the result is promoted according

Expires 22 August 1999                                         [Page 19]


Internet Draft   Distributed Management Expression MIB  22 February 1999

        to the following rules, in order from most to least preferred:

                If left hand and right hand operands are the same type,
                use that.

                If either side is Counter64, use that.

                If either side is IpAddress, use that.

                If either side is TimeTicks, use that.

                If either side is Counter32, use that.

                Otherwise use Unsigned32.

        The following rules say what operators apply with what data
        types.  Any combination not explicitly defined does not work.

        For all operators any of the following can be the left hand or
        right hand operand: Integer32, Counter32, Unsigned32, Counter64.

        The operators +, -, *, /, %, <, <=, >, and >= also work with
        TimeTicks.

        The operators &, |, and ^ also work with IpAddress.

        The operators << and >> also work with IpAddress but only as the
        left hand operand.

        The + operator performs a concatenation of two OCTET STRINGs or
        two OBJECT IDENTIFIERs.

        The operators &, | perform bitwise operations on OCTET STRINGs.
        If the OCTET STRING happens to be a DisplayString the results
        may be meaningless, but the agent system does not check this as
        some such systems do not have this information.

        The operators << and >> perform bitwise operations on OCTET
        STRINGs appearing as the left hand operand.

        The only functions defined are:

                counter32
                counter64
                arraySection

Expires 22 August 1999                                         [Page 20]


Internet Draft   Distributed Management Expression MIB  22 February 1999

                stringBegins
                stringEnds
                stringContains
                oidBegins
                oidEnds
                oidContains
                sum
                exists

        The following function definitions indicate their parameters by
        naming the data type of the parameter in the parameter's position
        in the parameter list.  The parameter must be of the type indicated
        and generally may be a constant, a MIB object, a function, or an
        expression.

        counter32(integer) - wrapped around an integer value counter32
        forces Counter32 as a data type.

        counter64(integer) - similar to counter32 except that the
        resulting data type is 'counter64'.

        arraySection(array, integer, integer) - selects a piece of an
        array (i.e. part of an OCTET STRING or OBJECT IDENTIFIER).  The
        integer arguments are in the range 0 to 4,294,967,295.  The
        first is an initial array index (1-based) and the second is an
        ending array index.  A value of 0 indicates first or last
        element, respectively.  If the first element is larger than the
        array length the result is 0 length.  If the second integer is
        less than or equal to the first, the result is 0 length.  If the
        second is larger than the array length it indicates last
        element.

        stringBegins/Ends/Contains(octetString, octetString) - looks for
        the second string (which can be a string constant) in the first
        and returns the 1-based index where the match began.  A return
        value of 0 indicates no match (i.e. boolean false).

        oidBegins/Ends/Contains(oid, oid) - looks for the second OID
        (which can be an OID constant) in the first and returns the
        the 1-based index where the match began.  A return value of 0
        indicates no match (i.e. boolean false).

        sum(integerObject*) - sums all available values of the
        wildcarded integer object, resulting in an integer scalar.  Must
        be used with caution as it wraps on overflow with no

Expires 22 August 1999                                         [Page 21]


Internet Draft   Distributed Management Expression MIB  22 February 1999

        notification.

        exists(anyTypeObject) - verifies the object instance exists. A
        return value of 0 indicates NoSuchInstance (i.e. boolean
        false)."
    ::= { expExpressionEntry 3 }

expExpressionValueType OBJECT-TYPE
    SYNTAX      INTEGER { counter32(1), unsigned32(2), timeTicks(3),
                          integer32(4), ipAddress(5), octetString(6),
                          objectId(7), counter64(8) }
    MAX-ACCESS  read-create
    STATUS      current
    DESCRIPTION
        "The type of the expression value.  One and only one of the
        value objects in expValueTable will be instantiated to match
        this type.

        If the result of the expression can not be made into this type,
        an invalidOperandType error will occur."
    DEFVAL      { counter32 }
    ::= { expExpressionEntry 4 }

expExpressionComment OBJECT-TYPE
    SYNTAX      SnmpAdminString
    MAX-ACCESS  read-create
    STATUS      current
    DESCRIPTION
        "A comment to explain the use or meaning of the expression."
    DEFVAL      { ''H }
    ::= { expExpressionEntry 5 }

expExpressionDeltaInterval OBJECT-TYPE
    SYNTAX      Integer32 (0..86400)
    UNITS       "seconds"
    MAX-ACCESS  read-create
    STATUS      current
    DESCRIPTION
        "Sampling interval for objects in this expression with
        expObjectSampleType 'deltaValue'.

        This object is has no effect if the the expression has no
        deltaValue objects.

        A value of 0 indicates no automated sampling.  In this case

Expires 22 August 1999                                         [Page 22]


Internet Draft   Distributed Management Expression MIB  22 February 1999

        the delta is the difference from the last time the expression
        was evaluated.  Note that this is subject to unpredictable
        delta times in the face of retries or multiple managers.

        A value greater than zero is the number of seconds between
        automated samples.

        Until the delta interval has expired once the delta for the
        object is effectively not instantiated and evaluating
        the expression has results as if the object itself were not
        instantiated.

        Note that delta values potentially consume large amounts of
        system CPU and memory.  Delta state and processing must
        continue constantly even if the expression is not being used.
        That is, the expression is being evaluated every delta interval,
        even if no application is reading those values.  For wildcarded
        objects this can be substantial overhead.

        Note that delta intervals, external expression value sampling
        intervals and delta intervals for expressions within other
        expressions can have unusual interactions as they are impossible
        to synchronize accurately.  In general one interval embedded
        below another must be enough shorter that the higher sample
        sees relatively smooth, predictable behavior.  So, for example,
        to avoid the higher level getting the same sample twice, the
        lower level should sample at least twice as fast as the higher
        level does."
    DEFVAL      { 0 }
    ::= { expExpressionEntry 6 }

expExpressionPrefix OBJECT-TYPE
    SYNTAX      OBJECT IDENTIFIER
    MAX-ACCESS  read-only
    STATUS      current
    DESCRIPTION
        "An object prefix to assist an application in determining
        the instance indexing to use in expValueTable, relieving the
        application of the need to scan the expObjectTable to
        determine such a prefix.

        See expObjectTable for information on wildcarded objects.

        If the expValueInstance portion of the value OID may
        be treated as a scalar (that is, normally, 0) the value of

Expires 22 August 1999                                         [Page 23]


Internet Draft   Distributed Management Expression MIB  22 February 1999

        expExpressionPrefix is zero length, that is, no OID at all.
        Note that zero length implies a null OID, not the OID 0.0.

        Otherwise, the value of expExpressionPrefix is the expObjectID
        value of any one of the wildcarded objects for the expression.
        This is sufficient, as the remainder, that is, the instance
        fragment relevant to instancing the values, must be the same for
        all wildcarded objects in the expression."
    ::= { expExpressionEntry 7 }

expExpressionErrors OBJECT-TYPE
    SYNTAX      Counter32
    MAX-ACCESS  read-only
    STATUS      current
    DESCRIPTION
        "The number of errors encountered while evaluating this
        expression.

        Note that an object in the expression not being accessible
        is not considered an error.  It is a legitimate condition
        that causes the corresponding expression value not to be
        instantiated."
    ::= { expExpressionEntry 8 }

expExpressionOwner OBJECT-TYPE
    SYNTAX      OwnerString
    MAX-ACCESS  read-create
    STATUS      current
    DESCRIPTION
        "The entity that configured this entry and is therefore using
        the resources assigned to it."
    DEFVAL      { "" }
    ::= { expExpressionEntry 9 }

expExpressionEntryStatus OBJECT-TYPE
    SYNTAX      RowStatus
    MAX-ACCESS  read-create
    STATUS      current
    DESCRIPTION
        "The control that allows creation and deletion of entries."
    ::= { expExpressionEntry 10 }

--
-- Expression Error Table

Expires 22 August 1999                                         [Page 24]


Internet Draft   Distributed Management Expression MIB  22 February 1999

--

expErrorTable OBJECT-TYPE
    SYNTAX      SEQUENCE OF ExpErrorEntry
    MAX-ACCESS  not-accessible
    STATUS      current
    DESCRIPTION
        "A table of expression errors."
    ::= { expDefine 2 }

expErrorEntry OBJECT-TYPE
    SYNTAX      ExpErrorEntry
    MAX-ACCESS  not-accessible
    STATUS      current
    DESCRIPTION
        "Information about errors in processing an expression.

        Entries appear in this table only when there is a matching
        expExpressionEntry and then only when there has been an
        error for that expression as reflected by the error codes
        defined for expErrorCode."
    INDEX       { expOwner, expExpressionName }
    ::= { expErrorTable 1 }

ExpErrorEntry ::= SEQUENCE {
    expErrorTime       TimeStamp,
    expErrorIndex      Integer32,
    expErrorCode       INTEGER,
    expErrorInstance   OBJECT IDENTIFIER
}

expErrorTime OBJECT-TYPE
    SYNTAX      TimeStamp
    MAX-ACCESS  read-only
    STATUS      current
    DESCRIPTION
        "The value of sysUpTime the last time an error caused a
        failure to evaluate this expression."
    ::= { expErrorEntry 1 }

expErrorIndex OBJECT-TYPE
    SYNTAX      Integer32
    MAX-ACCESS  read-only
    STATUS      current
    DESCRIPTION

Expires 22 August 1999                                         [Page 25]


Internet Draft   Distributed Management Expression MIB  22 February 1999

        "The 1-based character index into expExpression for where
        the error occurred.  The value zero indicates irrelevance."
    ::= { expErrorEntry 2 }

expErrorCode OBJECT-TYPE
    SYNTAX      INTEGER {
                invalidSyntax(1),
                undefinedObjectIndex(2),
                unrecognizedOperator(3),
                unrecognizedFunction(4),
                invalidOperandType(5),
                unmatchedParenthesis(6),
                tooManyWildcardValues(7),
                recursion(8),
                deltaTooShort(9),
                resourceUnavailable(10),
                divideByZero(11)
                }
    MAX-ACCESS  read-only
    STATUS      current
    DESCRIPTION
        "The error that occurred.  In the following explanations the
        expected timing of the error is in parentheses.  'S' means
        the error occurs on a Set request.  'E' means the error
        occurs on the attempt to evaluate the expression either due to
        Get from expValueTable or in ongoing delta processing.

        invalidSyntax           the value sent for expExpression is not
                                valid Expression MIB expression syntax
                                (S)
        undefinedObjectIndex    an object reference ($n) in
                                expExpression does not have a matching
                                instance in expObjectTable (E)
        unrecognizedOperator    the value sent for expExpression held an
                                unrecognized operator (S)
        unrecognizedFunction    the value sent for expExpression held an
                                unrecognized function name (S)
        invalidOperandType      an operand in expExpression is not the
                                right type for the associated operator
                                or result (SE)
        unmatchedParenthesis    the value sent for expExpression is not
                                correctly parenthesized (S)
        tooManyWildcardValues   evaluating the expression exceeded the
                                limit set by
                                expResourceDeltaWildcardInstanceMaximum

Expires 22 August 1999                                         [Page 26]


Internet Draft   Distributed Management Expression MIB  22 February 1999

                                (E)
        recursion               through some chain of embedded
                                expressions the expression invokes itself
                                (E)
        deltaTooShort           the delta for the next evaluation passed
                                before the system could evaluate the
                                present sample (E)
        resourceUnavailable     some resource, typically dynamic memory,
                                was unavailable (SE)
        divideByZero            an attempt to divide by zero occurred
                                (E)

        For the errors that occur when the attempt is made to set
        expExpression Set request fails with the SNMP error code
        'wrongValue'.  Such failures refer to the most recent failure to
        Set expExpression, not to the present value of expExpression
        which must be either unset or syntactically correct.

        Errors that occur during evaluation for a Get* operation return
        the SNMP error code 'genErr' except for 'tooManyWildcardValues'
        and 'resourceUnavailable' which return the SNMP error code
        'resourceUnavailable'."
    ::= { expErrorEntry 3 }

expErrorInstance OBJECT-TYPE
    SYNTAX      OBJECT IDENTIFIER
    MAX-ACCESS  read-only
    STATUS      current
    DESCRIPTION
        "The expValueInstance being evaluated when the error
        occurred.  A zero-length indicates irrelevance."
    ::= { expErrorEntry 4 }

--
-- Object Table
--

expObjectTable OBJECT-TYPE
    SYNTAX      SEQUENCE OF ExpObjectEntry
    MAX-ACCESS  not-accessible
    STATUS      current
    DESCRIPTION
        "A table of object definitions for each expExpression.

Expires 22 August 1999                                         [Page 27]


Internet Draft   Distributed Management Expression MIB  22 February 1999

        Wildcarding instance IDs:

        It is legal to omit all or part of the instance portion for
        some or all of the objects in an expression. (See the
        DESCRIPTION of expObjectID for details.  However, note that
        if more than one object in the same expression is wildcarded
        in this way, they all must be objects where that portion of
        the instance is the same.  In other words, all objects may be
        in the same SEQUENCE or in different SEQUENCEs but with the
        same semantic index value (e.g., a value of ifIndex)
        for the wildcarded portion."
    ::= { expDefine 3 }

expObjectEntry OBJECT-TYPE
    SYNTAX      ExpObjectEntry
    MAX-ACCESS  not-accessible
    STATUS      current
    DESCRIPTION
        "Information about an object.  An application uses
        expObjectEntryStatus to create entries in this table while
        in the process of defining an expression.

        Values of read-create objects in this table may be
        changed at any time."
    INDEX       { expOwner, expExpressionName, expObjectIndex }
    ::= { expObjectTable 1 }

ExpObjectEntry ::= SEQUENCE {
    expObjectIndex                     Unsigned32,
    expObjectID                        OBJECT IDENTIFIER,
    expObjectIDWildcard                TruthValue,
    expObjectSampleType                INTEGER,
    expObjectDeltaDiscontinuityID      OBJECT IDENTIFIER,
    expObjectDiscontinuityIDWildcard   TruthValue,
    expObjectDiscontinuityIDType       INTEGER,
    expObjectConditional               OBJECT IDENTIFIER,
    expObjectConditionalWildcard       TruthValue,
    expObjectENtryStatus               RowStatus
}

expObjectIndex OBJECT-TYPE
    SYNTAX      Unsigned32 (1..4294967295)
    MAX-ACCESS  not-accessible
    STATUS      current
    DESCRIPTION

Expires 22 August 1999                                         [Page 28]


Internet Draft   Distributed Management Expression MIB  22 February 1999

        "Within an expression, a unique, numeric identification for an
        object.  Prefixed with a dollar sign ('$') this is used to
        reference the object in the corresponding expExpression."
    ::= { expObjectEntry 1 }

expObjectID OBJECT-TYPE
    SYNTAX      OBJECT IDENTIFIER
    MAX-ACCESS  read-create
    STATUS      current
    DESCRIPTION
        "The OBJECT IDENTIFIER (OID) of this object.  The OID may be
        fully qualified, meaning it includes a complete instance
        identifier part (e.g., ifInOctets.1 or sysUpTime.0), or it
        may not be fully qualified, meaning it may lack all or part
        of the instance identifier.  If the expObjectID is not fully
        qualified, then expObjectWildcard must be set to true(1).
        The value of the expression will be multiple
        values, as if done for a GetNext sweep of the object.

        An object here may itself be the result of an expression but
        recursion is not allowed.

        NOTE:  The simplest implementations of this MIB may not allow
        wildcards."
    ::= { expObjectEntry 2 }

expObjectIDWildcard  OBJECT-TYPE
    SYNTAX      TruthValue
    MAX-ACCESS  read-create
    STATUS      current
    DESCRIPTION
        "A true value indicates the expObjecID of this row is a wildcard
        object. False indicates that expObjectID is fully instanced.
        If all expObjectWildcard values for a given expression are FALSE,
        expExpressionPrefix will reflect a scalar object (ie will
        be 0.0).

        NOTE:  The simplest implementations of this MIB may not allow
        wildcards."
    DEFVAL      { false }
    ::= { expObjectEntry 3 }

expObjectSampleType OBJECT-TYPE
    SYNTAX      INTEGER { absoluteValue(1), deltaValue(2),

Expires 22 August 1999                                         [Page 29]


Internet Draft   Distributed Management Expression MIB  22 February 1999

                          changedValue(3) }
    MAX-ACCESS  read-create
    STATUS      current
    DESCRIPTION
        "The method of sampling the selected variable.

        An 'absoluteValue' is simply the present value of the object.

        A 'deltaValue' is the present value minus the previous value,
        which was sampled expExpressionDeltaInterval seconds ago.
        This is intended primarily for use with SNMP counters, which are
        meaningless as an 'absoluteValue', but may be used with any
        integer-based value.

        A 'changedValue' is a boolean for whether the present value is
        different from the previous value.  It is applicable to any data
        type and results in an Unsigned32 with value 1 if the object's
        value is changed and 0 if not.  In all other respects it is as a
        'deltaValue' and all statements and operation regarding delta
        values apply to changed values.

        When an expression contains both delta and absolute values
        the absolute values are obtained at the end of the delta
        period."
    DEFVAL      { absoluteValue }
    ::= { expObjectEntry 4 }

sysUpTimeInstance OBJECT IDENTIFIER ::= { sysUpTime 0 }

expObjectDeltaDiscontinuityID OBJECT-TYPE
    SYNTAX      OBJECT IDENTIFIER
    MAX-ACCESS  read-create
    STATUS      current
    DESCRIPTION
        "The OBJECT IDENTIFIER (OID) of a TimeTicks or TimeStamp object
        that indicates a discontinuity in the value at expObjectID.

        This object is instantiated only if expObjectSampleType is
        'deltaValue' or 'changedValue'.

        The OID may be for a leaf object (e.g. sysUpTime.0) or may
        be wildcarded to match expObjectID.

        This object supports normal checking for a discontinuity in a
        counter.  Note that if this object does not point to sysUpTime

Expires 22 August 1999                                         [Page 30]


Internet Draft   Distributed Management Expression MIB  22 February 1999

        discontinuity checking must still check sysUpTime for an overall
        discontinuity.

        If the object identified is not accessible no discontinuity
        check will be made."
    DEFVAL      { sysUpTimeInstance }
    ::= { expObjectEntry 5 }

expObjectDiscontinuityIDWildcard OBJECT-TYPE
     SYNTAX      TruthValue
     MAX-ACCESS  read-create
     STATUS      current
     DESCRIPTION
        "A true value indicates the expObjectDeltaDiscontinuityID of
        this row is a wildcard object.  False indicates that
        expObjectDeltaDiscontinuityID is fully instanced.

        This object is instantiated only if expObjectSampleType is
        'deltaValue' or 'changedValue'.

        NOTE:  The simplest implementations of this MIB may not allow
        wildcards."
    DEFVAL      { false }
     ::= { expObjectEntry 6 }

expObjectDiscontinuityIDType OBJECT-TYPE
     SYNTAX      INTEGER { timeTicks(1), timeStamp(2), dateAndTime(3) }
     MAX-ACCESS  read-create
     STATUS      current
     DESCRIPTION
        "The value 'timeTicks' indicates the expObjectDeltaDiscontinuityID
        of this row is of syntax TimeTicks.  The value 'timeStamp' indicates
        syntax TimeStamp.  The value 'dateAndTime indicates syntax
        DateAndTime.

        This object is instantiated only if expObjectSampleType is
        'deltaValue' or 'changedValue'."
    DEFVAL      { timeTicks }
     ::= { expObjectEntry 7 }

zeroDotZero OBJECT IDENTIFIER ::= { 0 0 }

expObjectConditional OBJECT-TYPE
    SYNTAX      OBJECT IDENTIFIER
    MAX-ACCESS  read-create

Expires 22 August 1999                                         [Page 31]


Internet Draft   Distributed Management Expression MIB  22 February 1999

    STATUS      current
    DESCRIPTION
        "The OBJECT IDENTIFIER (OID) of an object that overrides
        whether the instance of expObjectID is to be considered
        usable.  If the value of the object at expObjectConditional
        is 0 or not instantiated, the object at expObjectID is
        treated as if it is not instantiated.  In other words,
        expObjectConditional is a filter that controls whether or
        not to use the value at expObjectID.

        The OID may be for a leaf object (e.g. sysObjectID.0) or may be
        wildcarded to match expObjectID.  If expObject is wildcarded and
        expObjectID in the same row is not, the wild portion of
        expObjectConditional must match the wildcarding of the rest of
        the expression.  If no object in the expression is wildcarded
        but expObjectConditional is, use the lexically first instance
        (if any) of expObjectConditional.

        If the value of expObjectConditional is 0.0 operation is
        as if the value pointed to by expObjectConditional is a
        non-zero (true) value.

        Note that expObjectConditional can not trivially use an object
        of syntax TruthValue, since the underlying value is not 0 or 1."
    DEFVAL      { zeroDotZero }
    ::= { expObjectEntry 8 }

 expObjectConditionalWildcard  OBJECT-TYPE
     SYNTAX      TruthValue
     MAX-ACCESS  read-create
     STATUS      current
     DESCRIPTION

        "A true value indicates the expObjectConditional of this row is
        a wildcard object. False indicates that expObjectConditional is
        fully instanced.

        NOTE: The simplest implementations of this MIB may not allow
        wildcards."
    DEFVAL      { false }
     ::= { expObjectEntry 9 }

expObjectEntryStatus OBJECT-TYPE
    SYNTAX      RowStatus
    MAX-ACCESS  read-create

Expires 22 August 1999                                         [Page 32]


Internet Draft   Distributed Management Expression MIB  22 February 1999

    STATUS      current
    DESCRIPTION
        "The control that allows creation/deletion of entries.

        Objects in this table may be changed while
        expObjectEntryStatus is in any state."
    ::= { expObjectEntry 10 }

--
-- Expression Value Table
--

expValueTable OBJECT-TYPE
    SYNTAX      SEQUENCE OF ExpValueEntry
    MAX-ACCESS  not-accessible
    STATUS      current
    DESCRIPTION
        "A table of values from evaluated expressions."
    ::= { expValue 1 }

expValueEntry OBJECT-TYPE
    SYNTAX      ExpValueEntry
    MAX-ACCESS  not-accessible
    STATUS      current
    DESCRIPTION
        "A single value from an evaluated expression.  For a given
        instance, only one 'Val' object in the conceptual row will be
        instantiated, that is, the one with the appropriate type for the
        value.  For values that contain no objects of
        expObjectSampleType 'deltaValue', reading a value from the table
        causes the evaluation of the expression for that value.  For
        those that contain a 'deltaValue' the value read is as of the
        last delta interval.

        If in the attempt to evaluate the expression one or more
        of the necessary objects is not available, the corresponding
        entry in this table is effectively not instantiated.

        To maintain security of MIB information, when creating a new
        row in this table, the managed system must record the security
        credentials of the requester.  These security credentials are
        the parameters necessary as inputs to isAccessAllowed from [1].
        When obtaining the objects that make up the expression, the
        system must (conceptually) use isAccessAllowed to ensure that
        it does not violate security.

Expires 22 August 1999                                         [Page 33]


Internet Draft   Distributed Management Expression MIB  22 February 1999

        If the subsequent expression includes objects with
        expObjectSampleType 'deltaValue' the evaluation of that expression
        takes place under the security credentials of the creator of its
        expExpressionEntry.

        To maintain security of MIB information, expression evaluation must
        take place using security credentials for the implied Gets of the
        objects in the expression as inputs (conceptually) to
        isAccessAllowed from the Architecture for Describing SNMP Management
        Frameworks.  For expressions with no deltaValue those security
        credentials are the ones that came with the Get* for the value.  For
        expressions with a deltaValue the ongoing expression evaluation is
        under the security credentials of the creator of the corresponding
        expNameEntry."
    INDEX       { expOwner, expExpressionName, IMPLIED expValueInstance }
    ::= { expValueTable 1 }

ExpValueEntry ::= SEQUENCE {
    expValueInstance          OBJECT IDENTIFIER,
    expValueCounter32Val      Counter32,
    expValueUnsigned32Val     Unsigned32,
    expValueTimeTicksVal      TimeTicks,
    expValueInteger32Val      Integer32,
    expValueIpAddressVal      IpAddress,
    expValueOctetStringVal    OCTET STRING,
    expValueOidVal            OBJECT IDENTIFIER,
    expValueCounter64Val      Counter64
}

expValueInstance OBJECT-TYPE
    SYNTAX      OBJECT IDENTIFIER
    MAX-ACCESS  not-accessible
    STATUS      current
    DESCRIPTION
        "The final instance portion of a value's OID according to
        the wildcarding in instances of expObjectID for the
        expression.  The prefix of this OID fragment is 0.0,
        leading to the following behavior.

        If there is no wildcarding, the value is 0.0.0.  In other
        words, there is one value which standing alone would have
        been a scalar with a 0 at the end of its OID.

        If there is wildcarding, the value is 0.0 followed by
        a value that the wildcard can take, thus defining one value

Expires 22 August 1999                                         [Page 34]


Internet Draft   Distributed Management Expression MIB  22 February 1999

        instance for each real, possible value of the wildcard.
        So, for example, if the wildcard worked out to be an ifIndex,
        there is an expValueInstance for each applicable ifIndex."
    ::= { expValueEntry 1 }

expValueCounter32Val OBJECT-TYPE
    SYNTAX      Counter32
    MAX-ACCESS  read-only
    STATUS      current
    DESCRIPTION
        "The value when expExpressionValueType is 'counter32'."
    ::= { expValueEntry 2 }

expValueUnsigned32Val OBJECT-TYPE
    SYNTAX      Unsigned32
    MAX-ACCESS  read-only
    STATUS      current
    DESCRIPTION
        "The value when expExpressionValueType is 'unsigned32'."
    ::= { expValueEntry 3 }

expValueTimeTicksVal OBJECT-TYPE
    SYNTAX      TimeTicks
    MAX-ACCESS  read-only
    STATUS      current
    DESCRIPTION
        "The value when expExpressionValueType is 'timeTicks'."
    ::= { expValueEntry 4 }

expValueInteger32Val OBJECT-TYPE
    SYNTAX      Integer32
    MAX-ACCESS  read-only
    STATUS      current
    DESCRIPTION
        "The value when expExpressionValueType is 'integer32'."
    ::= { expValueEntry 5 }

expValueIpAddressVal OBJECT-TYPE
    SYNTAX      IpAddress
    MAX-ACCESS  read-only
    STATUS      current
    DESCRIPTION
        "The value when expExpressionValueType is 'ipAddress'."
    ::= { expValueEntry 6 }

Expires 22 August 1999                                         [Page 35]


Internet Draft   Distributed Management Expression MIB  22 February 1999

expValueOctetStringVal OBJECT-TYPE
    SYNTAX      OCTET STRING (SIZE (0..65536))
    MAX-ACCESS  read-only
    STATUS      current
    DESCRIPTION
        "The value when expExpressionValueType is 'octetString'."
    ::= { expValueEntry 7 }

expValueOidVal OBJECT-TYPE
    SYNTAX      OBJECT IDENTIFIER
    MAX-ACCESS  read-only
    STATUS      current
    DESCRIPTION
        "The value when expExpressionValueType is 'objectId'."
    ::= { expValueEntry 8 }

expValueCounter64Val OBJECT-TYPE
    SYNTAX      Counter64
    MAX-ACCESS  read-only
    STATUS      current
    DESCRIPTION
        "The value when expExpressionValueType is 'counter64'."
    ::= { expValueEntry 9 }

--
-- Conformance
--

dismanExpressionMIBConformance OBJECT IDENTIFIER ::= { dismanExpressionMIB 3 }
dismanExpressionMIBCompliances OBJECT IDENTIFIER ::=
    { dismanExpressionMIBConformance 1 }
dismanExpressionMIBGroups      OBJECT IDENTIFIER ::=
    { dismanExpressionMIBConformance 2 }

-- Compliance

dismanExpressionMIBCompliance MODULE-COMPLIANCE
        STATUS current
        DESCRIPTION
                "The compliance statement for entities which implement
                the Expression MIB."
        MODULE  -- this module
                MANDATORY-GROUPS {
                        dismanExpressionResourceGroup,
                        dismanExpressionDefinitionGroup,

Expires 22 August 1999                                         [Page 36]


Internet Draft   Distributed Management Expression MIB  22 February 1999

                        dismanExpressionValueGroup
                }

        OBJECT         expResourceDeltaMinimum
        SYNTAX         Integer32 (-1 | 60..600)
        DESCRIPTION
                "Implementation need not allow deltas or it may
                implement them and restrict them to higher values."

        OBJECT         expObjectSampleType
        WRITE-SYNTAX   INTEGER { absoluteValue(1) }
        DESCRIPTION
                "Implementation may not allow deltas calculation or
                change detection."

        OBJECT         expObjectIDWildcard
        WRITE-SYNTAX   INTEGER { false(2) }
        DESCRIPTION
                "Implementation need not allow wildcards."

        OBJECT         expObjectDiscontinuityIDWildcard
        WRITE-SYNTAX   INTEGER { false(2) }
        DESCRIPTION
                "Implementation need not allow wildcards."

        OBJECT          expObjectConditionalWildcard
        WRITE-SYNTAX   INTEGER { false(2) }
        DESCRIPTION
                "Implementation need not allow deltas wildcards."

        OBJECT          expExpression
        SYNTAX          OCTET STRING (SIZE (2))
        DESCRIPTION
                "Implementation accept only single-object expressions."

        ::= { dismanExpressionMIBCompliances 1 }

-- Units of Conformance

dismanExpressionResourceGroup OBJECT-GROUP
        OBJECTS {
                expResourceDeltaMinimum,
                expResourceDeltaWildcardInstanceMaximum,
                expResourceDeltaWildcardInstances,
                expResourceDeltaWildcardInstancesHigh,

Expires 22 August 1999                                         [Page 37]


Internet Draft   Distributed Management Expression MIB  22 February 1999

                expResourceDeltaWildcardInstanceResourceLacks
        }
        STATUS current
        DESCRIPTION
                "Expression definition resource management."
        ::= { dismanExpressionMIBGroups 1 }

dismanExpressionDefinitionGroup OBJECT-GROUP
        OBJECTS {
                expExpression,
                expExpressionValueType,
                expExpressionComment,
                expExpressionDeltaInterval,
                expExpressionPrefix,
                expExpressionErrors,
                expExpressionOwner,
                expExpressionEntryStatus,

                expErrorTime,
                expErrorIndex,
                expErrorCode,
                expErrorInstance,

                expObjectID,
                expObjectIDWildcard,
                expObjectSampleType,
                expObjectDeltaDiscontinuityID,
                expObjectDiscontinuityIDWildcard,
                expObjectDiscontinuityIDType,
                expObjectConditional,
                expObjectConditionalWildcard,
                expObjectEntryStatus
        }
        STATUS current
        DESCRIPTION
                "Expression definition."
        ::= { dismanExpressionMIBGroups 2 }

dismanExpressionValueGroup OBJECT-GROUP
        OBJECTS {
                expValueCounter32Val,
                expValueUnsigned32Val,
                expValueTimeTicksVal,
                expValueInteger32Val,
                expValueIpAddressVal,

Expires 22 August 1999                                         [Page 38]


Internet Draft   Distributed Management Expression MIB  22 February 1999

                expValueOctetStringVal,
                expValueOidVal,
                expValueCounter64Val
        }
        STATUS current
        DESCRIPTION
                "Expression value."
        ::= { dismanExpressionMIBGroups 3 }

END

Expires 22 August 1999                                         [Page 39]


Internet Draft   Distributed Management Expression MIB  22 February 1999

5.  Intellectual Property

The IETF takes no position regarding the validity or scope of any
intellectual property or other rights that might be claimed to pertain
to the implementation or use of the technology described in this
document or the extent to which any license under such rights might or
might not be available; neither does it represent that it has made any
effort to identify any such rights.  Information on the IETF's
procedures with respect to rights in standards-track and standards-
related documentation can be found in BCP-11.  Copies of claims of
rights made available for publication and any assurances of licenses to
be made available, or the result of an attempt made to obtain a general
license or permission for the use of such proprietary rights by
implementors or users of this specification can be obtained from the
IETF Secretariat.

Expires 22 August 1999                                         [Page 40]


Internet Draft   Distributed Management Expression MIB  22 February 1999

6.  Acknowledgements

This MIB contains considerable contributions from the Distributed
Management Design Team (Andy Bierman, Maria Greene, Bob Stewart, and
Steve Waldbusser), and colleagues at Cisco who did the first
implemenation.

Expires 22 August 1999                                         [Page 41]


Internet Draft   Distributed Management Expression MIB  22 February 1999

7.  References

[1]  Harrington, D., Presuhn, R. and B. Wijnen, "An Architecture for
     Describing SNMP Management Frameworks", RFC 2271, Cabletron
     Systems, Inc., BMC Software, Inc., IBM T. J. Watson Research,
     January 1998.

[2]  Rose, M. and K. McCloghrie, "Structure and Identification of
     Management Information for TCP/IP-based Internets", RFC 1155,
     Performance Systems International, Hughes LAN Systems, May 1990.

[3]  Rose, M. and K. McCloghrie, "Concise MIB Definitions", RFC 1212,
     Performance Systems International, Hughes LAN Systems, March 1991.

[4]  M. Rose, "A Convention for Defining Traps for use with the SNMP",
     RFC 1215, Performance Systems International, March 1991.

[5]  Case, J., McCloghrie, K., Rose, M. and S. Waldbusser, "Structure of
     Management Information for Version 2 of the Simple Network
     Management Protocol (SNMPv2)", RFC 1902, SNMP Research,Inc., Cisco
     Systems, Inc., Dover Beach Consulting, Inc., International Network
     Services, January 1996.

[6]  Case, J., McCloghrie, K., Rose, M. and S. Waldbusser, "Textual
     Conventions for Version 2 of the Simple Network Management Protocol
     (SNMPv2)", RFC 1903, SNMP Research, Inc., Cisco Systems, Inc.,
     Dover Beach Consulting, Inc., International Network Services,
     January 1996.

[7]  Case, J., McCloghrie, K., Rose, M. and S. Waldbusser, "Conformance
     Statements for Version 2 of the Simple Network Management Protocol
     (SNMPv2)", RFC 1904, SNMP Research, Inc., Cisco Systems, Inc.,
     Dover Beach Consulting, Inc., International Network Services,
     January 1996.

[8]  Case, J., Fedor, M., Schoffstall, M. and J. Davin, "Simple Network
     Management Protocol", RFC 1157, SNMP Research, Performance Systems
     International, Performance Systems International, MIT Laboratory
     for Computer Science, May 1990.

[9]  Case, J., McCloghrie, K., Rose, M. and S. Waldbusser, "Introduction
     to Community-based SNMPv2", RFC 1901, SNMP Research, Inc., Cisco
     Systems, Inc., Dover Beach Consulting, Inc., International Network
     Services, January 1996.

Expires 22 August 1999                                         [Page 42]


Internet Draft   Distributed Management Expression MIB  22 February 1999

[10] Case, J., McCloghrie, K., Rose, M. and S. Waldbusser, "Transport
     Mappings for Version 2 of the Simple Network Management Protocol
     (SNMPv2)", RFC 1906, SNMP Research, Inc., Cisco Systems, Inc.,
     Dover Beach Consulting, Inc., International Network Services,
     January 1996.

[11] Case, J., Harrington D., Presuhn R. and B. Wijnen, "Message
     Processing and Dispatching for the Simple Network Management
     Protocol (SNMP)", RFC 2272, SNMP Research, Inc., Cabletron Systems,
     Inc., BMC Software, Inc., IBM T. J. Watson Research, January 1998.

[12] Blumenthal, U. and B. Wijnen, "User-based Security Model (USM) for
     version 3 of the Simple Network Management Protocol (SNMPv3)", RFC
     2274, IBM T. J. Watson Research, January 1998.

[13] Case, J., McCloghrie, K., Rose, M. and S. Waldbusser, "Protocol
     Operations for Version 2 of the Simple Network Management Protocol
     (SNMPv2)", RFC 1905, SNMP Research, Inc., Cisco Systems, Inc.,
     Dover Beach Consulting, Inc., International Network Services,
     January 1996.

[14] Levi, D., Meyer, P. and B. Stewart, "SNMPv3 Applications", RFC
     2273, SNMP Research, Inc., Secure Computing Corporation, Cisco
     Systems, January 1998.

[15] Wijnen, B., Presuhn, R. and K. McCloghrie, "View-based Access
     Control Model (VACM) for the Simple Network Management Protocol
     (SNMP)", RFC 2275, IBM T. J. Watson Research, BMC Software, Inc.,
     Cisco Systems, Inc., January 1998.

[16] Stewart, B., "Event MIB", RFC ????, Cisco Systems, Inc., ?Month?
     1998.

[17] Leinwand, A. and K. Fang, "Network Management: A Practical
     Perspective", Addison-Wesley Publishing Company, Inc., 1993.

Expires 22 August 1999                                         [Page 43]


Internet Draft   Distributed Management Expression MIB  22 February 1999

8.  Security Considerations

Expression MIB security involves two perspectives:  protection of
expressions from tampering or unauthorized use of resources, and
protection of the objects used to calculate the expressions.

Security of expression definitions and results depends on the expression
owner (expOwner.  With view-based access control [16] and expression
names with hierarchical structure a network manager can control who has
what level of access to what expressions.

Access control for the objects within the expression depends on when the
expression is evaluated.  For expressions of all absolute values the
security credentials used to get to the necessary objects are those of
the reader of the expression value.  For expressions containing delta or
changed values, the security credentials used at each polling period to
get the necessary objects are those used to set the expression
definition's RowStatus object to 'active'.

This means that the results of a delta or changed value expression could
potentially be made available to someone who does not have access to the
raw data that went into them.  This could be either legitimate or a
security violation, depending on the specific situation and security
policy.

To facilitate the provisioning of access control by a security
administrator for this MIB itself using the View-Based Access Control
Model (VACM) defined in RFC 2275 [16] for tables in which multiple users
may need to independently create or modify entries, the initial index is
used as an "owner index". Such an initial index has a syntax of
SnmpAdminString, and can thus be trivially mapped to a securityName or
groupName as defined in VACM, in accordance with a security policy.

All entries in related tables belonging to a particular user will have
the same value for this initial index.  For a given user's entries in a
particular table, the object identifiers for the information in these
entries will have the same subidentifiers (except for the "column"
subidentifier) up to the end of the encoded owner index. To configure
VACM to permit access to this portion of the table, one would create
vacmViewTreeFamilyTable entries with the value of
vacmViewTreeFamilySubtree including the owner index portion, and
vacmViewTreeFamilyMask "wildcarding" the column subidentifier.  More
elaborate configurations are possible.

Expires 22 August 1999                                         [Page 44]


Internet Draft   Distributed Management Expression MIB  22 February 1999

9.  Author's Address

     Bob Stewart
     Cisco Systems, Inc.
     170 West Tasman Drive
     San Jose, CA 95134-1706
     U.S.A.

     Phone: +1 408 526 4527
     Email: [email-masked]

Expires 22 August 1999                                         [Page 45]


Internet Draft   Distributed Management Expression MIB  22 February 1999

10.  Full Copyright Statement

Copyright (C) The Internet Society (1999). All Rights Reserved.

This document and translations of it may be copied and furnished to
others, and derivative works that comment on or otherwise explain it or
assist in its implementation may be prepared, copied, published and
distributed, in whole or in part, without restriction of any kind,
provided that the above copyright notice and this paragraph are included
on all such copies and derivative works.  However, this document itself
may not be modified in any way, such as by removing the copyright notice
or references to the Internet Society or other Internet organizations,
except as needed for the  purpose of developing Internet standards in
which case the procedures for copyrights defined in the Internet
Standards process must be followed, or as required to translate it into
languages other than English.

The limited permissions granted above are perpetual and will not be
revoked by the Internet Society or its successors or assigns.

This document and the information contained herein is provided on an "AS
IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING TASK
FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT
LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION HEREIN WILL NOT
INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR
FITNESS FOR A PARTICULAR PURPOSE.

Expires 22 August 1999                                         [Page 46]


Internet Draft   Distributed Management Expression MIB  22 February 1999

Table of Contents

1 Abstract ........................................................    2
2 The SNMP Management Framework ...................................    2
3 Overview ........................................................    4
3.1 Usage .........................................................    4
3.2 Operation .....................................................    5
3.2.1 Sampling ....................................................    5
3.2.2 Wildcards ...................................................    5
3.2.3 Evaluation ..................................................    6
3.2.4 Value Identification ........................................    6
3.3 Subsets .......................................................    7
3.3.1 No Wildcards ................................................    7
3.3.2 No Deltas ...................................................    7
3.3.3 One Object Expressions ......................................    7
3.4 Structure .....................................................    8
3.4.1 Resource ....................................................    8
3.4.2 Definition ..................................................    8
3.4.3 Value .......................................................    8
3.5 Examples ......................................................    9
3.5.1 Wildcarding .................................................    9
3.5.2 Calculation and Conditional .................................   10
4 Definitions .....................................................   13
5 Intellectual Property ...........................................   40
6 Acknowledgements ................................................   41
7 References ......................................................   42
8 Security Considerations .........................................   44
9 Author's Address ................................................   45
10 Full Copyright Statement .......................................   46

Expires 22 August 1999                                         [Page 47]