| 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 |
