mibs/ietf/DISMAN-EXPRESSION-MIB

   1 DISMAN-EXPRESSION-MIB DEFINITIONS ::= BEGIN
   2
   3 IMPORTS
   4     MODULE-IDENTITY, OBJECT-TYPE,
   5     Integer32, Gauge32, Unsigned32,
   6     Counter32, Counter64, IpAddress,
   7     TimeTicks, mib-2, zeroDotZero  FROM SNMPv2-SMI
   8     RowStatus, TruthValue, TimeStamp    FROM SNMPv2-TC
   9     sysUpTime                 FROM SNMPv2-MIB
  10     SnmpAdminString           FROM SNMP-FRAMEWORK-MIB
  11     MODULE-COMPLIANCE, OBJECT-GROUP     FROM SNMPv2-CONF;
  12
  13 dismanExpressionMIB MODULE-IDENTITY
  14     LAST-UPDATED "200010160000Z" -- 16 October 2000
  15     ORGANIZATION "IETF Distributed Management Working Group"
  16     CONTACT-INFO "Ramanathan Kavasseri
  17                   Cisco Systems, Inc.
  18                   170 West Tasman Drive,
  19                   San Jose CA 95134-1706.
  20                   Phone: +1 408 527 2446
  21                   Email: ramk@cisco.com"
  22     DESCRIPTION
  23      "The MIB module for defining expressions of MIB objects for
  24      management purposes."
  25 -- Revision History
  26
  27        REVISION     "200010160000Z" -- 16 October 2000
  28        DESCRIPTION  "This is the initial version of this MIB.
  29                     Published as RFC 2982"
  30     ::= { mib-2 90 }
  31
  32
  33 dismanExpressionMIBObjects OBJECT IDENTIFIER ::=
  34                                             { dismanExpressionMIB 1 }
  35
  36 expResource    OBJECT IDENTIFIER ::= { dismanExpressionMIBObjects 1 }
  37 expDefine OBJECT IDENTIFIER ::= { dismanExpressionMIBObjects 2 }
  38 expValue  OBJECT IDENTIFIER ::= { dismanExpressionMIBObjects 3 }
  39
  40 --
  41 -- Resource Control
  42 --
  43
  44
  45
  46 expResourceDeltaMinimum OBJECT-TYPE
  47     SYNTAX      Integer32 (-1 | 1..600)
  48     UNITS       "seconds"
  49     MAX-ACCESS  read-write
  50     STATUS      current
  51     DESCRIPTION
  52      "The minimum expExpressionDeltaInterval this system will
  53      accept.  A system may use the larger values of this minimum to
  54      lessen the impact of constantly computing deltas.  For larger
  55      delta sampling intervals the system samples less often and
  56      suffers less overhead.  This object provides a way to enforce
  57      such lower overhead for all expressions created after it is
  58      set.
  59
  60      The value -1 indicates that expResourceDeltaMinimum is
  61      irrelevant as the system will not accept 'deltaValue' as a
  62      value for expObjectSampleType.
  63
  64      Unless explicitly resource limited, a system's value for
  65      this object should be 1, allowing as small as a 1 second
  66      interval for ongoing delta sampling.
  67
  68      Changing this value will not invalidate an existing setting
  69      of expObjectSampleType."
  70     ::= { expResource 1 }
  71
  72 expResourceDeltaWildcardInstanceMaximum OBJECT-TYPE
  73     SYNTAX      Unsigned32
  74     UNITS       "instances"
  75     MAX-ACCESS  read-write
  76     STATUS      current
  77     DESCRIPTION
  78      "For every instance of a deltaValue object, one dynamic instance
  79      entry is needed for holding the instance value from the previous
  80      sample, i.e. to maintain state.
  81
  82      This object limits maximum number of dynamic instance entries
  83      this system will support for wildcarded delta objects in
  84      expressions. For a given delta expression, the number of
  85      dynamic instances is the number of values that meet all criteria
  86      to exist times the number of delta values in the expression.
  87
  88      A value of 0 indicates no preset limit, that is, the limit
  89      is dynamic based on system operation and resources.
  90
  91      Unless explicitly resource limited, a system's value for
  92      this object should be 0.
  93
  94
  95
  96      Changing this value will not eliminate or inhibit existing delta
  97      wildcard instance objects but will prevent the creation of more
  98      such objects.
  99
 100      An attempt to allocate beyond the limit results in expErrorCode
 101      being tooManyWildcardValues for that evaluation attempt."
 102     ::= { expResource 2 }
 103
 104 expResourceDeltaWildcardInstances OBJECT-TYPE
 105     SYNTAX      Gauge32
 106     UNITS       "instances"
 107     MAX-ACCESS  read-only
 108     STATUS      current
 109     DESCRIPTION
 110      "The number of currently active instance entries as
 111      defined for expResourceDeltaWildcardInstanceMaximum."
 112     ::= { expResource 3 }
 113
 114 expResourceDeltaWildcardInstancesHigh OBJECT-TYPE
 115     SYNTAX      Gauge32
 116     UNITS       "instances"
 117     MAX-ACCESS  read-only
 118     STATUS      current
 119     DESCRIPTION
 120      "The highest value of expResourceDeltaWildcardInstances
 121      that has occurred since initialization of the managed
 122      system."
 123     ::= { expResource 4 }
 124
 125 expResourceDeltaWildcardInstanceResourceLacks OBJECT-TYPE
 126     SYNTAX      Counter32
 127     UNITS       "instances"
 128     MAX-ACCESS  read-only
 129     STATUS      current
 130     DESCRIPTION
 131      "The number of times this system could not evaluate an
 132      expression because that would have created a value instance in
 133      excess of expResourceDeltaWildcardInstanceMaximum."
 134     ::= { expResource 5 }
 135
 136 --
 137
 138 -- Definition
 139 --
 140 -- Expression Definition Table
 141 --
 142
 143 expExpressionTable OBJECT-TYPE
 144
 145
 146     SYNTAX      SEQUENCE OF ExpExpressionEntry
 147     MAX-ACCESS  not-accessible
 148     STATUS      current
 149     DESCRIPTION
 150      "A table of expression definitions."
 151     ::= { expDefine 1 }
 152
 153 expExpressionEntry OBJECT-TYPE
 154     SYNTAX      ExpExpressionEntry
 155     MAX-ACCESS  not-accessible
 156     STATUS      current
 157     DESCRIPTION
 158      "Information about a single expression.  New expressions
 159      can be created using expExpressionRowStatus.
 160
 161      To create an expression first create the named entry in this
 162      table.  Then use expExpressionName to populate expObjectTable.
 163      For expression evaluation to succeed all related entries in
 164      expExpressionTable and expObjectTable must be 'active'.  If
 165      these conditions are not met the corresponding values in
 166      expValue simply are not instantiated.
 167
 168      Deleting an entry deletes all related entries in expObjectTable
 169      and expErrorTable.
 170
 171      Because of the relationships among the multiple tables for an
 172      expression (expExpressionTable, expObjectTable, and
 173      expValueTable) and the SNMP rules for independence in setting
 174      object values, it is necessary to do final error checking when
 175      an expression is evaluated, that is, when one of its instances
 176      in expValueTable is read or a delta interval expires.  Earlier
 177      checking need not be done and an implementation may not impose
 178      any ordering on the creation of objects related to an
 179      expression.
 180
 181      To maintain security of MIB information, when creating a new row in
 182      this table, the managed system must record the security credentials
 183      of the requester.  These security credentials are the parameters
 184      necessary as inputs to isAccessAllowed from the Architecture for
 185
 186      Describing SNMP Management Frameworks.  When obtaining the objects
 187      that make up the expression, the system must (conceptually) use
 188      isAccessAllowed to ensure that it does not violate security.
 189
 190      The evaluation of the expression takes place under the
 191      security credentials of the creator of its expExpressionEntry.
 192
 193      Values of read-write objects in this table may be changed
 194
 195
 196      at any time."
 197     INDEX       { expExpressionOwner, expExpressionName }
 198     ::= { expExpressionTable 1 }
 199
 200 ExpExpressionEntry ::= SEQUENCE {
 201     expExpressionOwner           SnmpAdminString,
 202     expExpressionName             SnmpAdminString,
 203     expExpression                OCTET STRING,
 204     expExpressionValueType       INTEGER,
 205     expExpressionComment         SnmpAdminString,
 206     expExpressionDeltaInterval   Integer32,
 207     expExpressionPrefix           OBJECT IDENTIFIER,
 208     expExpressionErrors          Counter32,
 209     expExpressionEntryStatus     RowStatus
 210 }
 211
 212 expExpressionOwner OBJECT-TYPE
 213    SYNTAX      SnmpAdminString (SIZE(0..32))
 214    MAX-ACCESS  not-accessible
 215    STATUS      current
 216    DESCRIPTION
 217      "The owner of this entry. The exact semantics of this
 218      string are subject to the security policy defined by the
 219      security administrator."
 220     ::= { expExpressionEntry 1 }
 221
 222 expExpressionName OBJECT-TYPE
 223     SYNTAX      SnmpAdminString (SIZE (1..32))
 224     MAX-ACCESS  not-accessible
 225     STATUS      current
 226     DESCRIPTION
 227      "The name of the expression.  This is locally unique, within
 228      the scope of an expExpressionOwner."
 229     ::= { expExpressionEntry 2 }
 230
 231 expExpression OBJECT-TYPE
 232     SYNTAX      OCTET STRING (SIZE (1..1024))
 233     MAX-ACCESS  read-create
 234     STATUS      current
 235     DESCRIPTION
 236      "The expression to be evaluated.  This object is the same
 237      as a DisplayString (RFC 1903) except for its maximum length.
 238
 239      Except for the variable names the expression is in ANSI C
 240      syntax.  Only the subset of ANSI C operators and functions
 241      listed here is allowed.
 242
 243      Variables are expressed as a dollar sign ('$') and an
 244
 245
 246      integer that corresponds to an expObjectIndex.  An
 247      example of a valid expression is:
 248
 249           ($1-$5)*100
 250
 251      Expressions must not be recursive, that is although an expression
 252      may use the results of another expression, it must not contain
 253      any variable that is directly or indirectly a result of its own
 254      evaluation. The managed system must check for recursive
 255      expressions.
 256
 257      The only allowed operators are:
 258
 259           ( )
 260           - (unary)
 261           + - * / %
 262           & | ^ << >> ~
 263           ! && || == != > >= < <=
 264
 265      Note the parentheses are included for parenthesizing the
 266      expression, not for casting data types.
 267
 268      The only constant types defined are:
 269
 270           int (32-bit signed)
 271           long (64-bit signed)
 272           unsigned int
 273           unsigned long
 274           hexadecimal
 275           character
 276           string
 277           oid
 278
 279      The default type for a positive integer is int unless it is too
 280      large in which case it is long.
 281
 282      All but oid are as defined for ANSI C.  Note that a
 283      hexadecimal constant may end up as a scalar or an array of
 284      8-bit integers.  A string constant is enclosed in double
 285      quotes and may contain back-slashed individual characters
 286      as in ANSI C.
 287
 288      An oid constant comprises 32-bit, unsigned integers and at
 289      least one period, for example:
 290
 291           0.
 292           .0
 293           1.3.6.1
 294
 295
 296      No additional leading or trailing subidentifiers are automatically
 297      added to an OID constant.  The constant is taken as expressed.
 298
 299      Integer-typed objects are treated as 32- or 64-bit, signed
 300      or unsigned integers, as appropriate.  The results of
 301      mixing them are as for ANSI C, including the type of the
 302      result.  Note that a 32-bit value is thus promoted to 64 bits
 303      only in an operation with a 64-bit value.  There is no
 304      provision for larger values to handle overflow.
 305
 306      Relative to SNMP data types, a resulting value becomes
 307      unsigned when calculating it uses any unsigned value,
 308      including a counter.  To force the final value to be of
 309      data type counter the expression must explicitly use the
 310      counter32() or counter64() function (defined below).
 311
 312      OCTET STRINGS and OBJECT IDENTIFIERs are treated as
 313      one-dimensioned arrays of unsigned 8-bit integers and
 314      unsigned 32-bit integers, respectively.
 315
 316      IpAddresses are treated as 32-bit, unsigned integers in
 317      network byte order, that is, the hex version of 255.0.0.0 is
 318      0xff000000.
 319
 320      Conditional expressions result in a 32-bit, unsigned integer
 321      of value 0 for false or 1 for true. When an arbitrary value
 322      is used as a boolean 0 is false and non-zero is true.
 323
 324      Rules for the resulting data type from an operation, based on
 325      the operator:
 326
 327      For << and >> the result is the same as the left hand operand.
 328
 329      For &&, ||, ==, !=, <, <=, >, and >= the result is always
 330      Unsigned32.
 331
 332      For unary - the result is always Integer32.
 333
 334      For +, -, *, /, %, &, |, and ^ the result is promoted according
 335      to the following rules, in order from most to least preferred:
 336
 337           If left hand and right hand operands are the same type,
 338           use that.
 339
 340           If either side is Counter64, use that.
 341
 342           If either side is IpAddress, use that.
 343
 344
 345
 346           If either side is TimeTicks, use that.
 347
 348           If either side is Counter32, use that.
 349
 350           Otherwise use Unsigned32.
 351
 352      The following rules say what operators apply with what data
 353      types.  Any combination not explicitly defined does not work.
 354
 355      For all operators any of the following can be the left hand or
 356      right hand operand: Integer32, Counter32, Unsigned32, Counter64.
 357
 358      The operators +, -, *, /, %, <, <=, >, and >= work with
 359      TimeTicks.
 360
 361      The operators &, |, and ^ work with IpAddress.
 362
 363      The operators << and >> work with IpAddress but only as the
 364      left hand operand.
 365
 366      The + operator performs a concatenation of two OCTET STRINGs or
 367      two OBJECT IDENTIFIERs.
 368
 369      The operators &, | perform bitwise operations on OCTET STRINGs.
 370      If the OCTET STRING happens to be a DisplayString the results
 371      may be meaningless, but the agent system does not check this as
 372      some such systems do not have this information.
 373
 374      The operators << and >> perform bitwise operations on OCTET
 375      STRINGs appearing as the left hand operand.
 376
 377      The only functions defined are:
 378
 379           counter32
 380           counter64
 381           arraySection
 382           stringBegins
 383           stringEnds
 384           stringContains
 385           oidBegins
 386           oidEnds
 387           oidContains
 388           average
 389           maximum
 390           minimum
 391           sum
 392           exists
 393
 394
 395
 396      The following function definitions indicate their parameters by
 397      naming the data type of the parameter in the parameter's position
 398      in the parameter list.  The parameter must be of the type indicated
 399      and generally may be a constant, a MIB object, a function, or an
 400      expression.
 401
 402      counter32(integer) - wrapped around an integer value counter32
 403      forces Counter32 as a data type.
 404
 405      counter64(integer) - similar to counter32 except that the
 406      resulting data type is 'counter64'.
 407
 408      arraySection(array, integer, integer) - selects a piece of an
 409      array (i.e. part of an OCTET STRING or OBJECT IDENTIFIER).  The
 410      integer arguments are in the range 0 to 4,294,967,295.  The
 411      first is an initial array index (one-dimensioned) and the second
 412      is an ending array index.  A value of 0 indicates first or last
 413      element, respectively.  If the first element is larger than the
 414      array length the result is 0 length.  If the second integer is
 415      less than or equal to the first, the result is 0 length.  If the
 416      second is larger than the array length it indicates last
 417      element.
 418
 419      stringBegins/Ends/Contains(octetString, octetString) - looks for
 420      the second string (which can be a string constant) in the first
 421      and returns the one-dimensioned arrayindex where the match began.
 422      A return value of 0 indicates no match (i.e. boolean false).
 423
 424      oidBegins/Ends/Contains(oid, oid) - looks for the second OID
 425      (which can be an OID constant) in the first and returns the
 426      the one-dimensioned index where the match began. A return value
 427      of 0 indicates no match (i.e. boolean false).
 428
 429      average/maximum/minimum(integer) - calculates the average,
 430      minimum, or maximum value of the integer valued object over
 431      multiple sample times.  If the object disappears for any
 432      sample period, the accumulation and the resulting value object
 433      cease to exist until the object reappears at which point the
 434      calculation starts over.
 435
 436      sum(integerObject*) - sums all available values of the
 437      wildcarded integer object, resulting in an integer scalar.  Must
 438      be used with caution as it wraps on overflow with no
 439      notification.
 440
 441      exists(anyTypeObject) - verifies the object instance exists. A
 442      return value of 0 indicates NoSuchInstance (i.e. boolean
 443      false)."
 444
 445
 446     ::= { expExpressionEntry 3 }
 447
 448 expExpressionValueType OBJECT-TYPE
 449     SYNTAX      INTEGER { counter32(1), unsigned32(2), timeTicks(3),
 450                  integer32(4), ipAddress(5), octetString(6),
 451                  objectId(7), counter64(8) }
 452     MAX-ACCESS  read-create
 453     STATUS      current
 454     DESCRIPTION
 455      "The type of the expression value.  One and only one of the
 456      value objects in expValueTable will be instantiated to match
 457      this type.
 458
 459      If the result of the expression can not be made into this type,
 460      an invalidOperandType error will occur."
 461     DEFVAL      { counter32 }
 462     ::= { expExpressionEntry 4 }
 463
 464 expExpressionComment OBJECT-TYPE
 465     SYNTAX      SnmpAdminString
 466     MAX-ACCESS  read-create
 467     STATUS      current
 468     DESCRIPTION
 469      "A comment to explain the use or meaning of the expression."
 470     DEFVAL      { ''H }
 471     ::= { expExpressionEntry 5 }
 472
 473 expExpressionDeltaInterval OBJECT-TYPE
 474     SYNTAX      Integer32 (0..86400)
 475     UNITS       "seconds"
 476     MAX-ACCESS  read-create
 477     STATUS      current
 478     DESCRIPTION
 479      "Sampling interval for objects in this expression with
 480      expObjectSampleType 'deltaValue'.
 481
 482      This object has no effect if the the expression has no
 483      deltaValue objects.
 484
 485      A value of 0 indicates no automated sampling.  In this case
 486      the delta is the difference from the last time the expression
 487      was evaluated.  Note that this is subject to unpredictable
 488      delta times in the face of retries or multiple managers.
 489
 490      A value greater than zero is the number of seconds between
 491      automated samples.
 492
 493      Until the delta interval has expired once the delta for the
 494
 495
 496      object is effectively not instantiated and evaluating
 497      the expression has results as if the object itself were not
 498      instantiated.
 499
 500      Note that delta values potentially consume large amounts of
 501      system CPU and memory.  Delta state and processing must
 502      continue constantly even if the expression is not being used.
 503      That is, the expression is being evaluated every delta interval,
 504      even if no application is reading those values.  For wildcarded
 505      objects this can be substantial overhead.
 506
 507      Note that delta intervals, external expression value sampling
 508      intervals and delta intervals for expressions within other
 509      expressions can have unusual interactions as they are impossible
 510      to synchronize accurately.  In general one interval embedded
 511      below another must be enough shorter that the higher sample
 512      sees relatively smooth, predictable behavior.  So, for example,
 513      to avoid the higher level getting the same sample twice, the
 514      lower level should sample at least twice as fast as the higher
 515      level does."
 516     DEFVAL      { 0 }
 517     ::= { expExpressionEntry 6 }
 518
 519 expExpressionPrefix OBJECT-TYPE
 520     SYNTAX      OBJECT IDENTIFIER
 521     MAX-ACCESS  read-only
 522     STATUS      current
 523     DESCRIPTION
 524      "An object prefix to assist an application in determining
 525      the instance indexing to use in expValueTable, relieving the
 526      application of the need to scan the expObjectTable to
 527      determine such a prefix.
 528
 529      See expObjectTable for information on wildcarded objects.
 530
 531      If the expValueInstance portion of the value OID may
 532      be treated as a scalar (that is, normally, 0) the value of
 533      expExpressionPrefix is zero length, that is, no OID at all.
 534      Note that zero length implies a null OID, not the OID 0.0.
 535
 536      Otherwise, the value of expExpressionPrefix is the expObjectID
 537      value of any one of the wildcarded objects for the expression.
 538      This is sufficient, as the remainder, that is, the instance
 539      fragment relevant to instancing the values, must be the same for
 540      all wildcarded objects in the expression."
 541     ::= { expExpressionEntry 7 }
 542
 543 expExpressionErrors OBJECT-TYPE
 544
 545
 546     SYNTAX      Counter32
 547     MAX-ACCESS  read-only
 548     STATUS      current
 549     DESCRIPTION
 550      "The number of errors encountered while evaluating this
 551      expression.
 552
 553      Note that an object in the expression not being accessible,
 554      is not considered an error. An example of an inaccessible
 555      object is when the object is excluded from the view of the
 556      user whose security credentials are used in the expression
 557      evaluation. In such cases, it is a legitimate condition
 558      that causes the corresponding expression value not to be
 559      instantiated."
 560     ::= { expExpressionEntry 8 }
 561
 562 expExpressionEntryStatus OBJECT-TYPE
 563     SYNTAX      RowStatus
 564     MAX-ACCESS  read-create
 565     STATUS      current
 566     DESCRIPTION
 567      "The control that allows creation and deletion of entries."
 568     ::= { expExpressionEntry 9 }
 569
 570 --
 571 -- Expression Error Table
 572 --
 573
 574 expErrorTable OBJECT-TYPE
 575     SYNTAX      SEQUENCE OF ExpErrorEntry
 576     MAX-ACCESS  not-accessible
 577     STATUS      current
 578     DESCRIPTION
 579      "A table of expression errors."
 580     ::= { expDefine 2 }
 581
 582 expErrorEntry OBJECT-TYPE
 583     SYNTAX      ExpErrorEntry
 584     MAX-ACCESS  not-accessible
 585     STATUS      current
 586     DESCRIPTION
 587      "Information about errors in processing an expression.
 588
 589      Entries appear in this table only when there is a matching
 590      expExpressionEntry and then only when there has been an
 591      error for that expression as reflected by the error codes
 592      defined for expErrorCode."
 593     INDEX       { expExpressionOwner, expExpressionName }
 594
 595
 596     ::= { expErrorTable 1 }
 597
 598 ExpErrorEntry ::= SEQUENCE {
 599     expErrorTime       TimeStamp,
 600     expErrorIndex      Integer32,
 601     expErrorCode       INTEGER,
 602     expErrorInstance   OBJECT IDENTIFIER
 603 }
 604
 605 expErrorTime OBJECT-TYPE
 606     SYNTAX      TimeStamp
 607     MAX-ACCESS  read-only
 608     STATUS      current
 609     DESCRIPTION
 610      "The value of sysUpTime the last time an error caused a
 611      failure to evaluate this expression."
 612     ::= { expErrorEntry 1 }
 613
 614 expErrorIndex OBJECT-TYPE
 615     SYNTAX      Integer32
 616     MAX-ACCESS  read-only
 617     STATUS      current
 618     DESCRIPTION
 619      "The one-dimensioned character array index into
 620      expExpression for where the error occurred.  The value
 621      zero indicates irrelevance."
 622     ::= { expErrorEntry 2 }
 623
 624 expErrorCode OBJECT-TYPE
 625     SYNTAX      INTEGER {
 626           invalidSyntax(1),
 627           undefinedObjectIndex(2),
 628           unrecognizedOperator(3),
 629           unrecognizedFunction(4),
 630           invalidOperandType(5),
 631           unmatchedParenthesis(6),
 632           tooManyWildcardValues(7),
 633           recursion(8),
 634           deltaTooShort(9),
 635           resourceUnavailable(10),
 636           divideByZero(11)
 637           }
 638     MAX-ACCESS  read-only
 639     STATUS      current
 640     DESCRIPTION
 641      "The error that occurred.  In the following explanations the
 642      expected timing of the error is in parentheses.  'S' means
 643      the error occurs on a Set request.  'E' means the error
 644
 645
 646      occurs on the attempt to evaluate the expression either due to
 647      Get from expValueTable or in ongoing delta processing.
 648
 649      invalidSyntax       the value sent for expExpression is not
 650                     valid Expression MIB expression syntax
 651                     (S)
 652      undefinedObjectIndex     an object reference ($n) in
 653                     expExpression does not have a matching
 654                     instance in expObjectTable (E)
 655      unrecognizedOperator     the value sent for expExpression held an
 656                     unrecognized operator (S)
 657      unrecognizedFunction     the value sent for expExpression held an
 658                     unrecognized function name (S)
 659      invalidOperandType  an operand in expExpression is not the
 660                     right type for the associated operator
 661                     or result (SE)
 662      unmatchedParenthesis     the value sent for expExpression is not
 663                     correctly parenthesized (S)
 664      tooManyWildcardValues    evaluating the expression exceeded the
 665                     limit set by
 666                     expResourceDeltaWildcardInstanceMaximum
 667                     (E)
 668      recursion      through some chain of embedded
 669                     expressions the expression invokes itself
 670                     (E)
 671      deltaTooShort       the delta for the next evaluation passed
 672                     before the system could evaluate the
 673                     present sample (E)
 674      resourceUnavailable some resource, typically dynamic memory,
 675                     was unavailable (SE)
 676      divideByZero        an attempt to divide by zero occurred
 677                     (E)
 678
 679      For the errors that occur when the attempt is made to set
 680      expExpression Set request fails with the SNMP error code
 681      'wrongValue'.  Such failures refer to the most recent failure to
 682      Set expExpression, not to the present value of expExpression
 683      which must be either unset or syntactically correct.
 684
 685      Errors that occur during evaluation for a Get* operation return
 686      the SNMP error code 'genErr' except for 'tooManyWildcardValues'
 687      and 'resourceUnavailable' which return the SNMP error code
 688      'resourceUnavailable'."
 689     ::= { expErrorEntry 3 }
 690
 691 expErrorInstance OBJECT-TYPE
 692     SYNTAX      OBJECT IDENTIFIER
 693     MAX-ACCESS  read-only
 694
 695
 696     STATUS      current
 697     DESCRIPTION
 698      "The expValueInstance being evaluated when the error
 699      occurred.  A zero-length indicates irrelevance."
 700     ::= { expErrorEntry 4 }
 701
 702 --
 703 -- Object Table
 704 --
 705
 706 expObjectTable OBJECT-TYPE
 707     SYNTAX      SEQUENCE OF ExpObjectEntry
 708     MAX-ACCESS  not-accessible
 709     STATUS      current
 710     DESCRIPTION
 711      "A table of object definitions for each expExpression.
 712
 713      Wildcarding instance IDs:
 714
 715      It is legal to omit all or part of the instance portion for
 716      some or all of the objects in an expression. (See the
 717      DESCRIPTION of expObjectID for details.  However, note that
 718      if more than one object in the same expression is wildcarded
 719      in this way, they all must be objects where that portion of
 720      the instance is the same.  In other words, all objects may be
 721      in the same SEQUENCE or in different SEQUENCEs but with the
 722      same semantic index value (e.g., a value of ifIndex)
 723      for the wildcarded portion."
 724     ::= { expDefine 3 }
 725
 726 expObjectEntry OBJECT-TYPE
 727     SYNTAX      ExpObjectEntry
 728     MAX-ACCESS  not-accessible
 729     STATUS      current
 730     DESCRIPTION
 731      "Information about an object.  An application uses
 732      expObjectEntryStatus to create entries in this table while
 733      in the process of defining an expression.
 734
 735      Values of read-create objects in this table may be
 736      changed at any time."
 737     INDEX       { expExpressionOwner, expExpressionName, expObjectIndex }
 738     ::= { expObjectTable 1 }
 739
 740 ExpObjectEntry ::= SEQUENCE {
 741     expObjectIndex                     Unsigned32,
 742     expObjectID                        OBJECT IDENTIFIER,
 743     expObjectIDWildcard                TruthValue,
 744
 745
 746     expObjectSampleType                INTEGER,
 747     expObjectDeltaDiscontinuityID      OBJECT IDENTIFIER,
 748     expObjectDiscontinuityIDWildcard   TruthValue,
 749     expObjectDiscontinuityIDType       INTEGER,
 750     expObjectConditional               OBJECT IDENTIFIER,
 751     expObjectConditionalWildcard       TruthValue,
 752     expObjectEntryStatus               RowStatus
 753 }
 754
 755 expObjectIndex OBJECT-TYPE
 756     SYNTAX      Unsigned32 (1..4294967295)
 757     MAX-ACCESS  not-accessible
 758     STATUS      current
 759     DESCRIPTION
 760      "Within an expression, a unique, numeric identification for an
 761      object.  Prefixed with a dollar sign ('$') this is used to
 762      reference the object in the corresponding expExpression."
 763     ::= { expObjectEntry 1 }
 764
 765 expObjectID OBJECT-TYPE
 766     SYNTAX      OBJECT IDENTIFIER
 767     MAX-ACCESS  read-create
 768     STATUS      current
 769     DESCRIPTION
 770      "The OBJECT IDENTIFIER (OID) of this object.  The OID may be
 771      fully qualified, meaning it includes a complete instance
 772      identifier part (e.g., ifInOctets.1 or sysUpTime.0), or it
 773      may not be fully qualified, meaning it may lack all or part
 774      of the instance identifier.  If the expObjectID is not fully
 775      qualified, then expObjectWildcard must be set to true(1).
 776      The value of the expression will be multiple
 777      values, as if done for a GetNext sweep of the object.
 778
 779      An object here may itself be the result of an expression but
 780      recursion is not allowed.
 781
 782      NOTE:  The simplest implementations of this MIB may not allow
 783      wildcards."
 784     ::= { expObjectEntry 2 }
 785
 786 expObjectIDWildcard  OBJECT-TYPE
 787     SYNTAX      TruthValue
 788     MAX-ACCESS  read-create
 789     STATUS      current
 790     DESCRIPTION
 791         "A true value indicates the expObjecID of this row is a wildcard
 792         object. False indicates that expObjectID is fully instanced.
 793         If all expObjectWildcard values for a given expression are FALSE,
 794
 795
 796         expExpressionPrefix will reflect a scalar object (i.e. will
 797         be 0.0).
 798
 799         NOTE:  The simplest implementations of this MIB may not allow
 800         wildcards."
 801     DEFVAL      { false }
 802     ::= { expObjectEntry 3 }
 803
 804 expObjectSampleType OBJECT-TYPE
 805     SYNTAX      INTEGER { absoluteValue(1), deltaValue(2),
 806                           changedValue(3) }
 807     MAX-ACCESS  read-create
 808     STATUS      current
 809     DESCRIPTION
 810      "The method of sampling the selected variable.
 811
 812      An 'absoluteValue' is simply the present value of the object.
 813
 814      A 'deltaValue' is the present value minus the previous value,
 815      which was sampled expExpressionDeltaInterval seconds ago.
 816      This is intended primarily for use with SNMP counters, which are
 817      meaningless as an 'absoluteValue', but may be used with any
 818      integer-based value.
 819
 820      A 'changedValue' is a boolean for whether the present value is
 821      different from the previous value.  It is applicable to any data
 822      type and results in an Unsigned32 with value 1 if the object's
 823      value is changed and 0 if not.  In all other respects it is as a
 824      'deltaValue' and all statements and operation regarding delta
 825      values apply to changed values.
 826
 827      When an expression contains both delta and absolute values
 828      the absolute values are obtained at the end of the delta
 829      period."
 830     DEFVAL      { absoluteValue }
 831     ::= { expObjectEntry 4 }
 832
 833 sysUpTimeInstance OBJECT IDENTIFIER ::= { sysUpTime 0 }
 834
 835 expObjectDeltaDiscontinuityID OBJECT-TYPE
 836     SYNTAX      OBJECT IDENTIFIER
 837     MAX-ACCESS  read-create
 838     STATUS      current
 839     DESCRIPTION
 840      "The OBJECT IDENTIFIER (OID) of a TimeTicks, TimeStamp, or
 841      DateAndTime object that indicates a discontinuity in the value
 842      at expObjectID.
 843
 844
 845
 846      This object is instantiated only if expObjectSampleType is
 847      'deltaValue' or 'changedValue'.
 848
 849      The OID may be for a leaf object (e.g. sysUpTime.0) or may
 850      be wildcarded to match expObjectID.
 851
 852      This object supports normal checking for a discontinuity in a
 853      counter.  Note that if this object does not point to sysUpTime
 854      discontinuity checking must still check sysUpTime for an overall
 855      discontinuity.
 856
 857      If the object identified is not accessible no discontinuity
 858      check will be made."
 859     DEFVAL      { sysUpTimeInstance }
 860     ::= { expObjectEntry 5 }
 861
 862 expObjectDiscontinuityIDWildcard OBJECT-TYPE
 863      SYNTAX      TruthValue
 864      MAX-ACCESS  read-create
 865      STATUS      current
 866      DESCRIPTION
 867      "A true value indicates the expObjectDeltaDiscontinuityID of
 868      this row is a wildcard object.  False indicates that
 869      expObjectDeltaDiscontinuityID is fully instanced.
 870
 871      This object is instantiated only if expObjectSampleType is
 872      'deltaValue' or 'changedValue'.
 873
 874      NOTE:  The simplest implementations of this MIB may not allow
 875      wildcards."
 876     DEFVAL      { false }
 877      ::= { expObjectEntry 6 }
 878
 879 expObjectDiscontinuityIDType OBJECT-TYPE
 880      SYNTAX      INTEGER { timeTicks(1), timeStamp(2), dateAndTime(3) }
 881      MAX-ACCESS  read-create
 882      STATUS      current
 883      DESCRIPTION
 884      "The value 'timeTicks' indicates the expObjectDeltaDiscontinuityID
 885      of this row is of syntax TimeTicks.  The value 'timeStamp' indicates
 886      syntax TimeStamp.  The value 'dateAndTime indicates syntax
 887      DateAndTime.
 888
 889      This object is instantiated only if expObjectSampleType is
 890      'deltaValue' or 'changedValue'."
 891     DEFVAL      { timeTicks }
 892      ::= { expObjectEntry 7 }
 893
 894
 895
 896 expObjectConditional OBJECT-TYPE
 897     SYNTAX      OBJECT IDENTIFIER
 898     MAX-ACCESS  read-create
 899     STATUS      current
 900     DESCRIPTION
 901      "The OBJECT IDENTIFIER (OID) of an object that overrides
 902      whether the instance of expObjectID is to be considered
 903      usable.  If the value of the object at expObjectConditional
 904      is 0 or not instantiated, the object at expObjectID is
 905      treated as if it is not instantiated.  In other words,
 906      expObjectConditional is a filter that controls whether or
 907      not to use the value at expObjectID.
 908
 909      The OID may be for a leaf object (e.g. sysObjectID.0) or may be
 910      wildcarded to match expObjectID.  If expObject is wildcarded and
 911      expObjectID in the same row is not, the wild portion of
 912      expObjectConditional must match the wildcarding of the rest of
 913      the expression.  If no object in the expression is wildcarded
 914      but expObjectConditional is, use the lexically first instance
 915      (if any) of expObjectConditional.
 916
 917      If the value of expObjectConditional is 0.0 operation is
 918      as if the value pointed to by expObjectConditional is a
 919      non-zero (true) value.
 920
 921      Note that expObjectConditional can not trivially use an object
 922      of syntax TruthValue, since the underlying value is not 0 or 1."
 923     DEFVAL      { zeroDotZero }
 924     ::= { expObjectEntry 8 }
 925
 926  expObjectConditionalWildcard  OBJECT-TYPE
 927      SYNTAX      TruthValue
 928      MAX-ACCESS  read-create
 929      STATUS      current
 930      DESCRIPTION
 931
 932      "A true value indicates the expObjectConditional of this row is
 933      a wildcard object. False indicates that expObjectConditional is
 934      fully instanced.
 935
 936      NOTE: The simplest implementations of this MIB may not allow
 937      wildcards."
 938     DEFVAL      { false }
 939      ::= { expObjectEntry 9 }
 940
 941 expObjectEntryStatus OBJECT-TYPE
 942     SYNTAX      RowStatus
 943     MAX-ACCESS  read-create
 944
 945
 946     STATUS      current
 947     DESCRIPTION
 948      "The control that allows creation/deletion of entries.
 949
 950      Objects in this table may be changed while
 951      expObjectEntryStatus is in any state."
 952     ::= { expObjectEntry 10 }
 953
 954 --
 955 -- Expression Value Table
 956 --
 957
 958 expValueTable OBJECT-TYPE
 959     SYNTAX      SEQUENCE OF ExpValueEntry
 960     MAX-ACCESS  not-accessible
 961     STATUS      current
 962     DESCRIPTION
 963      "A table of values from evaluated expressions."
 964     ::= { expValue 1 }
 965
 966 expValueEntry OBJECT-TYPE
 967     SYNTAX      ExpValueEntry
 968     MAX-ACCESS  not-accessible
 969     STATUS      current
 970     DESCRIPTION
 971      "A single value from an evaluated expression.  For a given
 972      instance, only one 'Val' object in the conceptual row will be
 973      instantiated, that is, the one with the appropriate type for
 974      the value.  For values that contain no objects of
 975      expObjectSampleType 'deltaValue' or 'changedValue', reading a
 976      value from the table causes the evaluation of the expression
 977      for that value.  For those that contain a 'deltaValue' or
 978      'changedValue' the value read is as of the last sampling
 979      interval.
 980
 981      If in the attempt to evaluate the expression one or more
 982      of the necessary objects is not available, the corresponding
 983      entry in this table is effectively not instantiated.
 984
 985      To maintain security of MIB information, when creating a new
 986      row in this table, the managed system must record the security
 987      credentials of the requester.  These security credentials are
 988      the parameters necessary as inputs to isAccessAllowed from
 989      [RFC2571]. When obtaining the objects that make up the
 990      expression, the system must (conceptually) use isAccessAllowed to
 991      ensure that it does not violate security.
 992
 993      The evaluation of that expression takes place under the
 994
 995
 996      security credentials of the creator of its expExpressionEntry.
 997
 998      To maintain security of MIB information, expression evaluation must
 999      take place using security credentials for the implied Gets of the
1000      objects in the expression as inputs (conceptually) to
1001      isAccessAllowed from the Architecture for Describing SNMP
1002      Management Frameworks.  These are the security credentials of the
1003      creator of the corresponding expExpressionEntry."
1004     INDEX       { expExpressionOwner, expExpressionName,
1005                   IMPLIED expValueInstance }
1006     ::= { expValueTable 1 }
1007
1008 ExpValueEntry ::= SEQUENCE {
1009     expValueInstance          OBJECT IDENTIFIER,
1010     expValueCounter32Val      Counter32,
1011     expValueUnsigned32Val     Unsigned32,
1012     expValueTimeTicksVal      TimeTicks,
1013     expValueInteger32Val      Integer32,
1014     expValueIpAddressVal      IpAddress,
1015     expValueOctetStringVal    OCTET STRING,
1016     expValueOidVal            OBJECT IDENTIFIER,
1017     expValueCounter64Val      Counter64
1018 }
1019
1020 expValueInstance OBJECT-TYPE
1021     SYNTAX      OBJECT IDENTIFIER
1022     MAX-ACCESS  not-accessible
1023     STATUS      current
1024     DESCRIPTION
1025      "The final instance portion of a value's OID according to
1026      the wildcarding in instances of expObjectID for the
1027      expression.  The prefix of this OID fragment is 0.0,
1028      leading to the following behavior.
1029
1030      If there is no wildcarding, the value is 0.0.0.  In other
1031      words, there is one value which standing alone would have
1032      been a scalar with a 0 at the end of its OID.
1033
1034      If there is wildcarding, the value is 0.0 followed by
1035      a value that the wildcard can take, thus defining one value
1036      instance for each real, possible value of the wildcard.
1037      So, for example, if the wildcard worked out to be an ifIndex,
1038      there is an expValueInstance for each applicable ifIndex."
1039     ::= { expValueEntry 1 }
1040
1041 expValueCounter32Val OBJECT-TYPE
1042     SYNTAX      Counter32
1043     MAX-ACCESS  read-only
1044
1045
1046     STATUS      current
1047     DESCRIPTION
1048      "The value when expExpressionValueType is 'counter32'."
1049     ::= { expValueEntry 2 }
1050
1051 expValueUnsigned32Val OBJECT-TYPE
1052     SYNTAX      Unsigned32
1053     MAX-ACCESS  read-only
1054     STATUS      current
1055     DESCRIPTION
1056      "The value when expExpressionValueType is 'unsigned32'."
1057     ::= { expValueEntry 3 }
1058
1059 expValueTimeTicksVal OBJECT-TYPE
1060     SYNTAX      TimeTicks
1061     MAX-ACCESS  read-only
1062     STATUS      current
1063     DESCRIPTION
1064      "The value when expExpressionValueType is 'timeTicks'."
1065     ::= { expValueEntry 4 }
1066
1067 expValueInteger32Val OBJECT-TYPE
1068     SYNTAX      Integer32
1069     MAX-ACCESS  read-only
1070     STATUS      current
1071     DESCRIPTION
1072      "The value when expExpressionValueType is 'integer32'."
1073     ::= { expValueEntry 5 }
1074
1075 expValueIpAddressVal OBJECT-TYPE
1076     SYNTAX      IpAddress
1077     MAX-ACCESS  read-only
1078     STATUS      current
1079     DESCRIPTION
1080      "The value when expExpressionValueType is 'ipAddress'."
1081     ::= { expValueEntry 6 }
1082
1083 expValueOctetStringVal OBJECT-TYPE
1084     SYNTAX      OCTET STRING -- (SIZE (0..65536))
1085     MAX-ACCESS  read-only
1086     STATUS      current
1087     DESCRIPTION
1088      "The value when expExpressionValueType is 'octetString'."
1089     ::= { expValueEntry 7 }
1090
1091 expValueOidVal OBJECT-TYPE
1092     SYNTAX      OBJECT IDENTIFIER
1093     MAX-ACCESS  read-only
1094
1095
1096     STATUS      current
1097     DESCRIPTION
1098      "The value when expExpressionValueType is 'objectId'."
1099     ::= { expValueEntry 8 }
1100
1101 expValueCounter64Val OBJECT-TYPE
1102     SYNTAX      Counter64
1103     MAX-ACCESS  read-only
1104     STATUS      current
1105     DESCRIPTION
1106      "The value when expExpressionValueType is 'counter64'."
1107     ::= { expValueEntry 9 }
1108
1109 --
1110 -- Conformance
1111 --
1112
1113 dismanExpressionMIBConformance OBJECT IDENTIFIER ::=
1114     { dismanExpressionMIB 3 }
1115 dismanExpressionMIBCompliances OBJECT IDENTIFIER ::=
1116     { dismanExpressionMIBConformance 1 }
1117 dismanExpressionMIBGroups      OBJECT IDENTIFIER ::=
1118     { dismanExpressionMIBConformance 2 }
1119
1120 -- Compliance
1121
1122 dismanExpressionMIBCompliance MODULE-COMPLIANCE
1123      STATUS current
1124      DESCRIPTION
1125           "The compliance statement for entities which implement
1126           the Expression MIB."
1127      MODULE    -- this module
1128           MANDATORY-GROUPS {
1129                dismanExpressionResourceGroup,
1130                dismanExpressionDefinitionGroup,
1131                dismanExpressionValueGroup
1132           }
1133
1134      OBJECT         expResourceDeltaMinimum
1135      SYNTAX         Integer32 (-1 | 60..600)
1136      DESCRIPTION
1137           "Implementation need not allow deltas or it may
1138           implement them and restrict them to higher values."
1139
1140      OBJECT         expObjectSampleType
1141      WRITE-SYNTAX   INTEGER { absoluteValue(1) }
1142      DESCRIPTION
1143           "Implementation may disallow deltas calculation or
1144
1145
1146           change detection."
1147
1148      OBJECT         expObjectIDWildcard
1149      WRITE-SYNTAX   INTEGER { false(2) }
1150      DESCRIPTION
1151           "Implementation may allow wildcards."
1152
1153      OBJECT         expObjectDiscontinuityIDWildcard
1154      WRITE-SYNTAX   INTEGER { false(2) }
1155      DESCRIPTION
1156           "Implementation need not allow wildcards."
1157
1158      OBJECT          expObjectConditionalWildcard
1159      WRITE-SYNTAX   INTEGER { false(2) }
1160      DESCRIPTION
1161           "Implementation need not allow deltas wildcards."
1162
1163      ::= { dismanExpressionMIBCompliances 1 }
1164
1165 -- Units of Conformance
1166
1167 dismanExpressionResourceGroup OBJECT-GROUP
1168      OBJECTS {
1169           expResourceDeltaMinimum,
1170           expResourceDeltaWildcardInstanceMaximum,
1171           expResourceDeltaWildcardInstances,
1172           expResourceDeltaWildcardInstancesHigh,
1173           expResourceDeltaWildcardInstanceResourceLacks
1174      }
1175      STATUS current
1176      DESCRIPTION
1177           "Expression definition resource management."
1178      ::= { dismanExpressionMIBGroups 1 }
1179
1180 dismanExpressionDefinitionGroup OBJECT-GROUP
1181      OBJECTS {
1182           expExpression,
1183           expExpressionValueType,
1184           expExpressionComment,
1185           expExpressionDeltaInterval,
1186           expExpressionPrefix,
1187           expExpressionErrors,
1188           expExpressionEntryStatus,
1189
1190           expErrorTime,
1191           expErrorIndex,
1192           expErrorCode,
1193           expErrorInstance,
1194
1195
1196           expObjectID,
1197           expObjectIDWildcard,
1198           expObjectSampleType,
1199           expObjectDeltaDiscontinuityID,
1200           expObjectDiscontinuityIDWildcard,
1201           expObjectDiscontinuityIDType,
1202           expObjectConditional,
1203           expObjectConditionalWildcard,
1204           expObjectEntryStatus
1205      }
1206      STATUS current
1207      DESCRIPTION
1208           "Expression definition."
1209      ::= { dismanExpressionMIBGroups 2 }
1210
1211 dismanExpressionValueGroup OBJECT-GROUP
1212      OBJECTS {
1213           expValueCounter32Val,
1214           expValueUnsigned32Val,
1215           expValueTimeTicksVal,
1216           expValueInteger32Val,
1217           expValueIpAddressVal,
1218           expValueOctetStringVal,
1219           expValueOidVal,
1220           expValueCounter64Val
1221      }
1222      STATUS current
1223      DESCRIPTION
1224           "Expression value."
1225      ::= { dismanExpressionMIBGroups 3 }
1226
1227 END