1206 lines
43 KiB
Plaintext
1206 lines
43 KiB
Plaintext
DISMAN-EXPRESSION-MIB DEFINITIONS ::= BEGIN
|
|
|
|
IMPORTS
|
|
MODULE-IDENTITY, OBJECT-TYPE,
|
|
Integer32, Gauge32, Unsigned32,
|
|
Counter32, Counter64, IpAddress,
|
|
TimeTicks, mib-2, zeroDotZero FROM SNMPv2-SMI
|
|
RowStatus, TruthValue, TimeStamp FROM SNMPv2-TC
|
|
sysUpTime FROM SNMPv2-MIB
|
|
SnmpAdminString FROM SNMP-FRAMEWORK-MIB
|
|
MODULE-COMPLIANCE, OBJECT-GROUP FROM SNMPv2-CONF;
|
|
|
|
dismanExpressionMIB MODULE-IDENTITY
|
|
LAST-UPDATED "200010160000Z" -- 16 October 2000
|
|
ORGANIZATION "IETF Distributed Management Working Group"
|
|
CONTACT-INFO "Ramanathan Kavasseri
|
|
Cisco Systems, Inc.
|
|
170 West Tasman Drive,
|
|
San Jose CA 95134-1706.
|
|
Phone: +1 408 527 2446
|
|
Email: ramk@cisco.com"
|
|
DESCRIPTION
|
|
"The MIB module for defining expressions of MIB objects for
|
|
management purposes."
|
|
-- Revision History
|
|
|
|
REVISION "200010160000Z" -- 16 October 2000
|
|
DESCRIPTION "This is the initial version of this MIB.
|
|
Published as RFC 2982"
|
|
::= { mib-2 90 }
|
|
|
|
|
|
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
|
|
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. For larger
|
|
delta sampling intervals the system samples less often and
|
|
suffers less overhead. This object provides a way to enforce
|
|
such lower overhead for all expressions created after it is
|
|
set.
|
|
|
|
The value -1 indicates that expResourceDeltaMinimum is
|
|
irrelevant as the system will not accept 'deltaValue' as a
|
|
value for expObjectSampleType.
|
|
|
|
Unless explicitly resource limited, a system's value for
|
|
this object should be 1, allowing as small as a 1 second
|
|
interval for ongoing delta sampling.
|
|
|
|
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
|
|
"For every instance of a deltaValue object, one dynamic instance
|
|
entry is needed for holding the instance value from the previous
|
|
sample, i.e. to maintain state.
|
|
|
|
This object limits maximum number of dynamic instance entries
|
|
this system will support for wildcarded delta objects in
|
|
expressions. For a given delta expression, the number of
|
|
dynamic 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 evaluation attempt."
|
|
::= { 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 managed
|
|
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 }
|
|
|
|
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.
|
|
|
|
The evaluation of the 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 { expExpressionOwner, expExpressionName }
|
|
::= { expExpressionTable 1 }
|
|
|
|
ExpExpressionEntry ::= SEQUENCE {
|
|
expExpressionOwner SnmpAdminString,
|
|
expExpressionName SnmpAdminString,
|
|
expExpression OCTET STRING,
|
|
expExpressionValueType INTEGER,
|
|
expExpressionComment SnmpAdminString,
|
|
expExpressionDeltaInterval Integer32,
|
|
expExpressionPrefix OBJECT IDENTIFIER,
|
|
expExpressionErrors Counter32,
|
|
expExpressionEntryStatus RowStatus
|
|
}
|
|
|
|
expExpressionOwner 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 expExpressionOwner."
|
|
::= { 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.
|
|
|
|
Except for the variable names the expression is in ANSI C
|
|
syntax. Only the subset of ANSI C operators and functions
|
|
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 must not be recursive, that is although an expression
|
|
may use the results of another expression, it must not contain
|
|
any variable that is directly or indirectly a result of its own
|
|
evaluation. The managed system must check for recursive
|
|
expressions.
|
|
|
|
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
|
|
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
|
|
one-dimensioned 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 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 >= work with
|
|
TimeTicks.
|
|
|
|
The operators &, |, and ^ work with IpAddress.
|
|
|
|
The operators << and >> 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
|
|
oidBegins
|
|
oidEnds
|
|
oidContains
|
|
average
|
|
maximum
|
|
minimum
|
|
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 (one-dimensioned) 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 one-dimensioned arrayindex 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 one-dimensioned index where the match began. A return value
|
|
of 0 indicates no match (i.e. boolean false).
|
|
|
|
average/maximum/minimum(integer) - calculates the average,
|
|
minimum, or maximum value of the integer valued object over
|
|
multiple sample times. If the object disappears for any
|
|
sample period, the accumulation and the resulting value object
|
|
cease to exist until the object reappears at which point the
|
|
calculation starts over.
|
|
|
|
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
|
|
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 has no effect if the the expression has no
|
|
deltaValue objects.
|
|
|
|
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
|
|
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
|
|
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. An example of an inaccessible
|
|
object is when the object is excluded from the view of the
|
|
user whose security credentials are used in the expression
|
|
evaluation. In such cases, it is a legitimate condition
|
|
that causes the corresponding expression value not to be
|
|
instantiated."
|
|
::= { expExpressionEntry 8 }
|
|
|
|
expExpressionEntryStatus OBJECT-TYPE
|
|
SYNTAX RowStatus
|
|
MAX-ACCESS read-create
|
|
STATUS current
|
|
DESCRIPTION
|
|
"The control that allows creation and deletion of entries."
|
|
::= { expExpressionEntry 9 }
|
|
|
|
--
|
|
-- Expression Error Table
|
|
--
|
|
|
|
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 { expExpressionOwner, 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
|
|
"The one-dimensioned character array 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
|
|
(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.
|
|
|
|
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 { expExpressionOwner, 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
|
|
"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 (i.e. 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),
|
|
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, TimeStamp, or
|
|
DateAndTime 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
|
|
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 }
|
|
|
|
|
|
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.
|
|
|
|
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
|
|
|
|
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' or 'changedValue', reading a
|
|
value from the table causes the evaluation of the expression
|
|
for that value. For those that contain a 'deltaValue' or
|
|
'changedValue' the value read is as of the last sampling
|
|
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
|
|
[RFC2571]. When obtaining the objects that make up the
|
|
expression, the system must (conceptually) use isAccessAllowed to
|
|
ensure that it does not violate security.
|
|
|
|
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. These are the security credentials of the
|
|
creator of the corresponding expExpressionEntry."
|
|
INDEX { expExpressionOwner, 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
|
|
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 }
|
|
|
|
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,
|
|
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 disallow deltas calculation or
|
|
|
|
change detection."
|
|
|
|
OBJECT expObjectIDWildcard
|
|
WRITE-SYNTAX INTEGER { false(2) }
|
|
DESCRIPTION
|
|
"Implementation may 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."
|
|
|
|
::= { dismanExpressionMIBCompliances 1 }
|
|
|
|
-- Units of Conformance
|
|
|
|
dismanExpressionResourceGroup OBJECT-GROUP
|
|
OBJECTS {
|
|
expResourceDeltaMinimum,
|
|
expResourceDeltaWildcardInstanceMaximum,
|
|
expResourceDeltaWildcardInstances,
|
|
expResourceDeltaWildcardInstancesHigh,
|
|
expResourceDeltaWildcardInstanceResourceLacks
|
|
}
|
|
STATUS current
|
|
DESCRIPTION
|
|
"Expression definition resource management."
|
|
::= { dismanExpressionMIBGroups 1 }
|
|
|
|
dismanExpressionDefinitionGroup OBJECT-GROUP
|
|
OBJECTS {
|
|
expExpression,
|
|
expExpressionValueType,
|
|
expExpressionComment,
|
|
expExpressionDeltaInterval,
|
|
expExpressionPrefix,
|
|
expExpressionErrors,
|
|
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,
|
|
expValueOctetStringVal,
|
|
expValueOidVal,
|
|
expValueCounter64Val
|
|
}
|
|
STATUS current
|
|
DESCRIPTION
|
|
"Expression value."
|
|
::= { dismanExpressionMIBGroups 3 }
|
|
|
|
END
|
|
|
|
|