Internet Draft Expression MIB 21 November 1997
Expression MIB
21 November 1997
draft-ietf-disman-express-mib-03.txt
Bob Stewart
Cisco Systems, Inc.
bstewart@cisco.com
Status of this Memo
This document is an Internet-Draft. 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.''
To learn the current status of any Internet-Draft, please check the
``1id-abstracts.txt'' listing contained in the Internet- Drafts Shadow
Directories on ds.internic.net (US East Coast), nic.nordu.net (Europe),
ftp.isi.edu (US West Coast), or munnari.oz.au (Pacific Rim).
9
9Expires 21 November 1997+6 months [Page 1]
Internet Draft Expression MIB 21 November 1997
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.
9
9Expires 21 November 1997+6 months [Page 2]
Internet Draft Expression MIB 21 November 1997
2. The SNMP Network Management Framework
They are: The SNMP Network Management Framework presently consists of
three major components. They are:
the SMI, described in RFC 1902 [1] - the mechanisms used for
describing and naming objects for the purpose of management.
the MIB-II, STD 17, RFC 1213 [2] - the core set of managed objects for
the Internet suite of protocols.
the protocol, RFC 1157 [3] and/or RFC 1905 [4], - the protocol for
accessing managed objects.
The Framework permits new objects to be defined for the purpose of
experimentation and evaluation.
2.1. Object Definitions
Managed objects are accessed via a virtual information store, termed the
Management Information Base or MIB. Objects in the MIB are defined
using the subset of Abstract Syntax Notation One (ASN.1) defined in the
SMI. In particular, each object type is named by an OBJECT IDENTIFIER,
an administratively assigned name. The object type together with an
object instance serves to uniquely identify a specific instantiation of
the object. For human convenience, we often use a textual string,
termed the descriptor, to refer to the object type.
9
9Expires 21 November 1997+6 months [Page 3]
Internet Draft Expression MIB 21 November 1997
3. Overview
The MIB was designed around the basic premise that an evaluated
expression should result in a MIB object that appears no different from
any other and is thus usable anywhere any other MIB object can be used,
whether by a management application directly or via another MIB.
Note that the operation of this MIB depends on the ability to use OID
fragments, that is, a part of an OID that may be missing the usual
prefix starting with iso. It is the opinion of the author that such a
use is legitimate even if it violates some pure definition of ASN.1,
since SNMP's use of ASN.1 is colloquial, not standard. Implementation
experience has shown that such use is practical from the agent
perspective.
Although this MIB represents a relatively high-level application,
implementation of the 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 that is the expected environment and it is not
reasonable that the MIB should assume a full-blown application-level
environment.
9
9Expires 21 November 1997+6 months [Page 4]
Internet Draft Expression MIB 21 November 1997
4. Definitions
EXPRESSION-MIB DEFINITIONS ::= BEGIN
IMPORTS
MODULE-IDENTITY, OBJECT-TYPE,
Integer32, Gauge32,
Counter32, Counter64, IpAddress FROM SNMPv2-SMI
TEXTUAL-CONVENTION, RowStatus,TruthValue,
TimeStamp, DisplayString FROM SNMPv2-TC
ciscoExperiment FROM CISCO-SMI
Unsigned32 FROM CISCO-TC
OwnerString FROM IF-MIB
sysUpTime FROM SNMPv2-MIB
MODULE-COMPLIANCE, OBJECT-GROUP FROM SNMPv2-CONF;
expressionMIB MODULE-IDENTITY
LAST-UPDATED "9711211700Z"
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: bstewart@cisco.com"
DESCRIPTION
"The MIB module for defining expressions of MIB objects
for network management purposes."
::= { ciscoExperiment 22 }
ExpressionName ::= TEXTUAL-CONVENTION
STATUS current
DESCRIPTION
"An identification for an expression. An ExpressionName
corresponds one-to-one to an ExpressionIndex.
This identification of an expression is subject to change
only by administrative request."
SYNTAX DisplayString (SIZE (1..64))
ExpressionIndex ::= TEXTUAL-CONVENTION
STATUS current
DESCRIPTION
"An integer shorthand identification for an expression.
An ExpressionIndex corresponds one-to-one to an
Expires 21 November 1997+6 months [Page 5]
Internet Draft Expression MIB 21 November 1997
ExpressionName.
Once assigned an ExpressionIndex may not be changed."
SYNTAX Unsigned32 (1..4294967295)
ExpressionIndexOrZero ::= TEXTUAL-CONVENTION
STATUS current
DESCRIPTION
"Either an ExpressionIndex or zero. The meaning of zero
depends on the DESCRIPTION of the object."
SYNTAX Unsigned32 (0..4294967295)
expressionMIBObjects OBJECT IDENTIFIER ::= { expressionMIB 1 }
expResource OBJECT IDENTIFIER ::= { expressionMIBObjects 1 }
expNames OBJECT IDENTIFIER ::= { expressionMIBObjects 2 }
expDefine OBJECT IDENTIFIER ::= { expressionMIBObjects 3 }
expValue OBJECT IDENTIFIER ::= { expressionMIBObjects 4 }
--
-- Wildcarding Example
--
-- This example refers to tables and objects defined below. It may well
-- make more sense after reading those definitions.
--
-- 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
-- ...
Expires 21 November 1997+6 months [Page 6]
Internet Draft Expression MIB 21 November 1997
-- 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
-- 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.
--
Expires 21 November 1997+6 months [Page 7]
Internet Draft Expression MIB 21 November 1997
--
-- Resource Control
--
expResourceDeltaMinimum OBJECT-TYPE
SYNTAX Integer32 (-1 | 1..600)
UNITS "seconds"
MAX-ACCESS read-write
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.
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."
Expires 21 November 1997+6 months [Page 8]
Internet Draft Expression MIB 21 November 1997
::= { expResource 2 }
expResourceDeltaWildcardInstances OBJECT-TYPE
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 create a value instance in excess of
expResourceDeltaWildcardInstanceMaximum."
::= { expResource 5 }
--
-- Naming & Creation
--
expNameLastChange OBJECT-TYPE
SYNTAX TimeStamp
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The value of sysUpTime the last time an expression was
Expires 21 November 1997+6 months [Page 9]
Internet Draft Expression MIB 21 November 1997
created or deleted or had its name changed using
expExpressionName."
::= { expNames 1 }
expNameHighestIndex OBJECT-TYPE
SYNTAX ExpressionIndexOrZero
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The highest value of ExpressionIndex ever assigned on
this system. Preferrably this value is preserved across
system reboots. A managed system that is unable to
store expressions across reboots need not preserve this
value across reboots.
If all expression-creating applications cooperate, they
may use this to avoid reusing an ExpressionIndex. To
do so, attempt creation of a new entry with this
value + 1 as the value of expExpressionIndex.
Although reusing ExpressionIndexes could lead to an
application receiving a misunderstood value, it is a
matter of local management policy whether to reuse them."
::= { expNames 2 }
--
-- Name Creation Table
--
expNameTable OBJECT-TYPE
SYNTAX SEQUENCE OF ExpNameEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"A table of expression names, for creating and deleting
expressions."
::= { expNames 3 }
expNameEntry OBJECT-TYPE
SYNTAX ExpNameEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"Information about a single expression. New expressions
can be created using expNameStatus.
Expires 21 November 1997+6 months [Page 10]
Internet Draft Expression MIB 21 November 1997
To create an expression first create the named entry in this
table. Then use expExpressionIndex to populate
expExpressionTable and expObjectTable. For expression
evaluation to succeed all related entries in expNameTable,
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
expExpressionTable and expObjectTable.
Because of the relationships among the multiple tables
for an expression (expNameTable, 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. Earlier checking need not be
done and an implementation may not impose any ordering
on the creation of objects related to an expression other
than to require values for expName and expExpressionIndex
before any other related objects can be created.
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. 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 expNameEntry."
INDEX { IMPLIED expName }
::= { expNameTable 1 }
ExpNameEntry ::= SEQUENCE {
expName ExpressionName,
expExpressionIndex ExpressionIndex,
expNameStatus RowStatus
}
expName OBJECT-TYPE
SYNTAX ExpressionName
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"The name of the expression. Choosing names with useful
lexical ordering supports using GetNext or GetBulk to
Expires 21 November 1997+6 months [Page 11]
Internet Draft Expression MIB 21 November 1997
retrieve a useful subset of the table."
::= { expNameEntry 1 }
expExpressionIndex OBJECT-TYPE
SYNTAX ExpressionIndex
MAX-ACCESS read-create
STATUS current
DESCRIPTION
"The numeric identification of the expression.
Applications may select this number in ascending numerical
order by using expNameHighestIndex as a hint or may use any
other acceptable, unused number.
Once set this value may not be set to a different value."
::= { expNameEntry 2 }
expNameStatus OBJECT-TYPE
SYNTAX RowStatus
MAX-ACCESS read-create
STATUS current
DESCRIPTION
"The control that allows creation/deletion of entries."
::= { expNameEntry 3 }
--
-- 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 }
expExpressionEntry OBJECT-TYPE
SYNTAX ExpExpressionEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"Information about a single expression. An entry appears in
Expires 21 November 1997+6 months [Page 12]
Internet Draft Expression MIB 21 November 1997
this table when an entry is created in expNameTable. Deleting
that expNameTable entry automatically deletes this entry and its
associated expObjectTable entries.
Values of read-write objects in this table may be changed
at any time."
INDEX { expExpressionIndex }
::= { expExpressionTable 1 }
ExpExpressionEntry ::= SEQUENCE {
expExpressionName ExpressionName,
expExpression OCTET STRING,
expExpressionValueType INTEGER,
expExpressionComment DisplayString,
expExpressionDeltaInterval Integer32,
expExpressionPrefix OBJECT IDENTIFIER,
expExpressionErrors Counter32,
expExpressionErrorTime TimeStamp,
expExpressionErrorIndex Integer32,
expExpressionError INTEGER,
expExpressionInstance OBJECT IDENTIFIER,
expExpressionOwner OwnerString
}
expExpressionName OBJECT-TYPE
SYNTAX ExpressionName
MAX-ACCESS read-write
STATUS current
DESCRIPTION
"The unique name of the expression, the same as expName.
Use this object to change the expression's name without
changing its expExpressionIndex."
::= { expExpressionEntry 1 }
expExpression OBJECT-TYPE
SYNTAX OCTET STRING (SIZE (1..1024))
MAX-ACCESS read-write
STATUS current
DESCRIPTION
"The expression to be evaluated. This object is the same
as a DisplayString (RFC 1903) except for its maximum length.
Except for the variable names the expression is in ANSI C
syntax. Only the subset of ANSI C operators and functions
Expires 21 November 1997+6 months [Page 13]
Internet Draft Expression MIB 21 November 1997
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 21 November 1997+6 months [Page 14]
Internet Draft Expression MIB 21 November 1997
least one period, for example:
0.
.0
1.3.6.1
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 to
the following rules, in order from most to least preferred:
If left hand and right hand operands are the same type, use
Expires 21 November 1997+6 months [Page 15]
Internet Draft Expression MIB 21 November 1997
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
stringBegins
stringEnds
stringContains
Expires 21 November 1997+6 months [Page 16]
Internet Draft Expression MIB 21 November 1997
oidBegins
oidEnds
oidContains
sum
exists
The following function definitions indicate their 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 availiable values of the wildcarded
integer object, resulting in an integer scalar. Must be used
with caution as it wraps on overflow with no notification.
exists(anyTypeObject) - verifies the object instance exists. A
return value of 0 indicates NoSuchInstance (i.e. boolean false)."
::= { expExpressionEntry 2 }
Expires 21 November 1997+6 months [Page 17]
Internet Draft Expression MIB 21 November 1997
expExpressionValueType OBJECT-TYPE
SYNTAX INTEGER { counter32(1), unsignedOrGauge32(2),
timeTicks(3), integer32(4), ipAddress(5),
octetString(6), objectId(7), counter64(8) }
MAX-ACCESS read-write
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 3 }
expExpressionComment OBJECT-TYPE
SYNTAX DisplayString
MAX-ACCESS read-write
STATUS current
DESCRIPTION
"A comment to explain the use or meaning of the expression."
DEFVAL { ''H }
::= { expExpressionEntry 4 }
expExpressionDeltaInterval OBJECT-TYPE
SYNTAX Integer32 (0..86400)
UNITS "seconds"
MAX-ACCESS read-write
STATUS current
DESCRIPTION
"Sampling interval for objects in this expression with
expObjectSampleType 'deltaValue'.
This object is not instantiated if not applicable.
A value of 0 indicates no automated sampling. In this case
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
Expires 21 November 1997+6 months [Page 18]
Internet Draft Expression MIB 21 November 1997
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."
DEFVAL { 0 }
::= { expExpressionEntry 5 }
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
expExpressionPrefix is zero length, that is, no OID at all.
Otherwise expExpressionPrefix is the value of any wildcarded
instance of expObjectID 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 6 }
expExpressionErrors OBJECT-TYPE
SYNTAX Counter32
MAX-ACCESS read-only
Expires 21 November 1997+6 months [Page 19]
Internet Draft Expression MIB 21 November 1997
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 7 }
expExpressionErrorTime 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.
This object is not instantiated if there have been no
errors."
::= { expExpressionEntry 8 }
expExpressionErrorIndex OBJECT-TYPE
SYNTAX Integer32
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The 1-based character index into expExpression for where
the error occurred. The value zero indicates irrelevance.
This object is not instantiated if there have been no
errors."
::= { expExpressionEntry 9 }
expExpressionError OBJECT-TYPE
SYNTAX INTEGER {
invalidSyntax(1),
undefinedObjectIndex(2),
unrecognizedOperator(3),
unrecognizedFunction(4),
invalidOperandType(5),
unmatchedParenthesis(6),
tooManyWildcardValues(7),
recursion(8),
Expires 21 November 1997+6 months [Page 20]
Internet Draft Expression MIB 21 November 1997
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 (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.
9
9Expires 21 November 1997+6 months [Page 21]
Internet Draft Expression MIB 21 November 1997
Errors that occur during evalutaion for a Get* operation return
the SNMP error code 'genErr' except for 'tooManyWildcardValues'
and 'resourceUnavailable' which return the SNMP error code
'resourceUnavailable'.
This object is not instantiated if there have been no
errors."
::= { expExpressionEntry 10 }
expExpressionInstance 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.
This object is not instantiated if there have been no
errors."
::= { expExpressionEntry 11 }
expExpressionOwner OBJECT-TYPE
SYNTAX OwnerString
MAX-ACCESS read-write
STATUS current
DESCRIPTION
"The entity that configured this entry and is therefore using the
resources assigned to it."
DEFVAL { "" }
::= { expExpressionEntry 12 }
--
-- Object Table
--
expObjectTable OBJECT-TYPE
SYNTAX SEQUENCE OF ExpObjectEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"A table of object definitions for each expExpression.
Wildcarding instance IDs:
It is legal to omit all or part of the instance portion for
Expires 21 November 1997+6 months [Page 22]
Internet Draft Expression MIB 21 November 1997
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 2 }
expObjectEntry OBJECT-TYPE
SYNTAX ExpObjectEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"Information about an object. An application uses
expObjectStatus 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 { expExpressionIndex, 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,
expObjectStatus RowStatus
}
expObjectIndex OBJECT-TYPE
SYNTAX Unsigned32 (1..4294967295)
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"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."
Expires 21 November 1997+6 months [Page 23]
Internet Draft Expression MIB 21 November 1997
::= { 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) }
MAX-ACCESS read-create
STATUS current
DESCRIPTION
Expires 21 November 1997+6 months [Page 24]
Internet Draft Expression MIB 21 November 1997
"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.
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 }
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 not instantiated if expObject is not 'deltaValue'.
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
discontinuity checking must still check sysUpTime for an overall
discontinuity.
If the object identified is not accessible no discontinuity
check will be made."
DEFVAL { sysUpTime 0 }
::= { expObjectEntry 5 }
expObjectDiscontinuityIDWildcard OBJECT-TYPE
SYNTAX TruthValue
MAX-ACCESS read-create
STATUS current
DESCRIPTION
"A true value indicates the expObjectDeltaDiscontinuityID of this
Expires 21 November 1997+6 months [Page 25]
Internet Draft Expression MIB 21 November 1997
row is a wildcard object. False indicates that
expObjectDeltaDiscontinuityID is fully instanced.
This object is not instantiated if expObject is not 'deltaValue'.
NOTE: The simplest implementations of this MIB may not allow
wildcards."
DEFVAL { false }
::= { expObjectEntry 6 }
expObjectDiscontinuityIDType OBJECT-TYPE
SYNTAX INTEGER { timeTicks(1), timeStamp(2) }
MAX-ACCESS read-create
STATUS current
DESCRIPTION
"The value 'timeTicks' indicates the expObjectDeltaDiscontinuityID
of this row is of syntax TimeTicks. The value 'timeStamp'
indicates that expObjectDeltaDiscontinuityID is of syntax
TimeStamp.
This object is not instantiated if expObject is not 'deltaValue'."
DEFVAL { timeTicks }
::= { expObjectEntry 7 }
expObjectConditional OBJECT-TYPE
SYNTAX OBJECT IDENTIFIER
MAX-ACCESS read-create
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.
9
9Expires 21 November 1997+6 months [Page 26]
Internet Draft Expression MIB 21 November 1997
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 }
expObjectStatus OBJECT-TYPE
SYNTAX RowStatus
MAX-ACCESS read-create
STATUS current
DESCRIPTION
"The control that allows creation/deletion of entries.
Objects in this table may be changed while expObjectStatus
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."
Expires 21 November 1997+6 months [Page 27]
Internet Draft Expression MIB 21 November 1997
::= { 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, expression evaluation
must take place using security credentials for the implied
Gets of the objects in the expression. 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 { expExpressionIndex, IMPLIED expValueInstance }
::= { expValueTable 1 }
ExpValueEntry ::= SEQUENCE {
expValueInstance OBJECT IDENTIFIER,
expValueCounter32Val Counter32,
expValueUnsigned32Val Unsigned32,
expValueInteger32Val Integer32,
expValueIpAddressVal IpAddress,
expValueOctetStringVal OCTET STRING,
expValueOidVal OBJECT IDENTIFIER,
expValueCounter64Val Counter64
}
expValueInstance OBJECT-TYPE
SYNTAX OBJECT IDENTIFIER
MAX-ACCESS not-accessible
Expires 21 November 1997+6 months [Page 28]
Internet Draft Expression MIB 21 November 1997
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
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 'unsignedOrGauge32'
or 'timeTicks'."
::= { expValueEntry 3 }
expValueInteger32Val OBJECT-TYPE
SYNTAX Integer32
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The value when expExpressionValueType is 'integer32'."
::= { expValueEntry 4 }
expValueIpAddressVal OBJECT-TYPE
SYNTAX IpAddress
Expires 21 November 1997+6 months [Page 29]
Internet Draft Expression MIB 21 November 1997
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The value when expExpressionValueType is 'ipAddress'."
::= { expValueEntry 5 }
expValueOctetStringVal OBJECT-TYPE
SYNTAX OCTET STRING (SIZE (0..65536))
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The value when expExpressionValueType is 'octetString'."
::= { expValueEntry 6 }
expValueOidVal OBJECT-TYPE
SYNTAX OBJECT IDENTIFIER
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The value when expExpressionValueType is 'objectId'."
::= { expValueEntry 7 }
expValueCounter64Val OBJECT-TYPE
SYNTAX Counter64
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The value when expExpressionValueType is 'counter64'."
::= { expValueEntry 8 }
--
-- Conformance
--
expressionMIBConformance OBJECT IDENTIFIER ::= { expressionMIB 3 }
expressionMIBCompliances OBJECT IDENTIFIER ::= { expressionMIBConformance 1 }
expressionMIBGroups OBJECT IDENTIFIER ::= { expressionMIBConformance 2 }
-- Compliance
expressionMIBCompliance MODULE-COMPLIANCE
STATUS current
DESCRIPTION
"The compliance statement for entities which implement
the Expression MIB."
Expires 21 November 1997+6 months [Page 30]
Internet Draft Expression MIB 21 November 1997
MODULE -- this module
MANDATORY-GROUPS {
expressionResourceGroup,
expressionDefinitionGroup,
expressionValueGroup
}
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."
::= { expressionMIBCompliances 1 }
-- Units of Conformance
expressionResourceGroup OBJECT-GROUP
OBJECTS {
expResourceDeltaMinimum,
expResourceDeltaWildcardInstanceMaximum,
expResourceDeltaWildcardInstances,
expResourceDeltaWildcardInstancesHigh,
expResourceDeltaWildcardInstanceResourceLacks
}
STATUS current
DESCRIPTION
"Expression definition resource management."
::= { expressionMIBGroups 1 }
expressionDefinitionGroup OBJECT-GROUP
OBJECTS {
expNameLastChange,
expNameHighestIndex,
expExpressionIndex,
expNameStatus,
expExpressionName,
expExpression,
expExpressionValueType,
Expires 21 November 1997+6 months [Page 31]
Internet Draft Expression MIB 21 November 1997
expExpressionComment,
expExpressionDeltaInterval,
expExpressionPrefix,
expExpressionErrors,
expExpressionErrorTime,
expExpressionErrorIndex,
expExpressionError,
expExpressionInstance,
expExpressionOwner,
expObjectID,
expObjectSampleType,
expObjectDeltaDiscontinuityID,
expObjectDiscontinuityIDWildcard,
expObjectConditional,
expObjectConditionalWildcard,
expObjectStatus
}
STATUS current
DESCRIPTION
"Expression definition resource management."
::= { expressionMIBGroups 2 }
expressionValueGroup OBJECT-GROUP
OBJECTS {
expValueCounter32Val,
expValueUnsigned32Val,
expValueInteger32Val,
expValueIpAddressVal,
expValueOctetStringVal,
expValueOidVal,
expValueCounter64Val
}
STATUS current
DESCRIPTION
"Expression definition resource management."
::= { expressionMIBGroups 3 }
END
9
9Expires 21 November 1997+6 months [Page 32]
Internet Draft Expression MIB 21 November 1997
5. Acknowledgements
This MIB contains considerable contributions from the RMON MIB, the
Distributed Management Design Team (Andy Bierman, Maria Greene, Bob
Stewart, and Steve Waldbusser), and colleagues at Cisco who did the
first implemenation.
9
9Expires 21 November 1997+6 months [Page 33]
Internet Draft Expression MIB 21 November 1997
6. References
[1] SNMPv2 Working Group, 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,
January 1996.
[2] McCloghrie, K., and M. Rose, Editors, "Management Information Base
for Network Management of TCP/IP-based internets: MIB-II", STD 17,
RFC 1213, March 1991.
[3] Case, J., Fedor, M., Schoffstall, M., and J. Davin, "Simple Network
Management Protocol", RFC 1157, May 1990.
[4] SNMPv2 Working Group, Case, J., McCloghrie, K., Rose, M., and
S. Waldbusser, "Protocol Operations for version 2 of the Simple
Network Management Protocol (SNMPv2)", RFC 1905, January 1996.
9
9Expires 21 November 1997+6 months [Page 34]
Internet Draft Expression MIB 21 November 1997
7. Security Considerations
Security is discussed in the body of the MIB itself.
8. Author's Address
Bob Stewart
Cisco Systems, Inc.
170 West Tasman Drive
San Jose, CA 95134-1706
Phone: 408-526-4527
Email: bstewart@cisco.com
9
9Expires 21 November 1997+6 months [Page 35]
Internet Draft Expression MIB 21 November 1997
Table of Contents
1 Abstract ........................................................ 2
2 The SNMP Network Management Framework ........................... 3
2.1 Object Definitions ............................................ 3
3 Overview ........................................................ 4
4 Definitions ..................................................... 5
5 Acknowledgements ................................................ 33
6 References ...................................................... 34
7 Security Considerations ......................................... 35
8 Author's Address ................................................ 35
9
9Expires 21 November 1997+6 months [Page 36]
