diff options
Diffstat (limited to 'mibs/DISMAN-EXPRESSION-MIB.txt')
| -rw-r--r-- | mibs/DISMAN-EXPRESSION-MIB.txt | 1182 |
1 files changed, 1182 insertions, 0 deletions
diff --git a/mibs/DISMAN-EXPRESSION-MIB.txt b/mibs/DISMAN-EXPRESSION-MIB.txt new file mode 100644 index 00000000..f73e5bf5 --- /dev/null +++ b/mibs/DISMAN-EXPRESSION-MIB.txt @@ -0,0 +1,1182 @@ +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 |