inetcidrroutetablepdu.java

snmp zip 包开发snmp协议

               set to -1.
  Default Value: -1
)<br/>
*/
public void setInetCidrRouteMetric4(AsnObject new_value)
{
    AsnInteger obj = (AsnInteger) new_value;
    _inetCidrRouteMetric4 = new Integer(obj.getValue());
}
public Integer getInetCidrRouteMetric4()
{
    return _inetCidrRouteMetric4;
}


/**
inetCidrRouteMetric5<br/>
TYPE Integer32 ::= [UNIVERSAL 2] INTEGER (-2147483648..2147483647)<br/>
OBJECT-TYPE (
  Syntax: [UNIVERSAL 2] INTEGER (-2147483648..2147483647)
  Access: read-create
  Status: current
  Description: An alternate routing metric for this route.  The
               semantics of this metric are determined by the routing- 
               protocol specified in the route's inetCidrRouteProto  
               value.  If this metric is not used, its value should be  
               set to -1.
  Default Value: -1
)<br/>
*/
public void setInetCidrRouteMetric5(AsnObject new_value)
{
    AsnInteger obj = (AsnInteger) new_value;
    _inetCidrRouteMetric5 = new Integer(obj.getValue());
}
public Integer getInetCidrRouteMetric5()
{
    return _inetCidrRouteMetric5;
}


/**
inetCidrRouteStatus<br/>
TYPE RowStatus ::= TEXTUAL-CONVENTION (
  Status: current
  Description: The RowStatus textual convention is used to manage the
               creation and deletion of conceptual rows, and is used as the
               value of the SYNTAX clause for the status column of a
               conceptual row (as described in Section 7.7.1 of [2].)
               
               The status column has six defined values:
               
                    - `active', which indicates that the conceptual row is
                    available for use by the managed device;
               
                    - `notInService', which indicates that the conceptual
                    row exists in the agent, but is unavailable for use by
                    the managed device (see NOTE below); 'notInService' has
                    no implication regarding the internal consistency of
                    the row, availability of resources, or consistency with
                    the current state of the managed device;
               
                    - `notReady', which indicates that the conceptual row
                    exists in the agent, but is missing information
                    necessary in order to be available for use by the
                    managed device (i.e., one or more required columns in
                    the conceptual row have not been instanciated);
               
                    - `createAndGo', which is supplied by a management
                    station wishing to create a new instance of a
                    conceptual row and to have its status automatically set
                    to active, making it available for use by the managed
                    device;
               
                    - `createAndWait', which is supplied by a management
                    station wishing to create a new instance of a
                    conceptual row (but not make it available for use by
                    the managed device); and,
                    - `destroy', which is supplied by a management station
                    wishing to delete all of the instances associated with
                    an existing conceptual row.
               
               Whereas five of the six values (all except `notReady') may
               be specified in a management protocol set operation, only
               three values will be returned in response to a management
               protocol retrieval operation:  `notReady', `notInService' or
               `active'.  That is, when queried, an existing conceptual row
               has only three states:  it is either available for use by
               the managed device (the status column has value `active');
               it is not available for use by the managed device, though
               the agent has sufficient information to attempt to make it
               so (the status column has value `notInService'); or, it is
               not available for use by the managed device, and an attempt
               to make it so would fail because the agent has insufficient
               information (the state column has value `notReady').
               
                                        NOTE WELL
               
                    This textual convention may be used for a MIB table,
                    irrespective of whether the values of that table's
                    conceptual rows are able to be modified while it is
                    active, or whether its conceptual rows must be taken
                    out of service in order to be modified.  That is, it is
                    the responsibility of the DESCRIPTION clause of the
                    status column to specify whether the status column must
                    not be `active' in order for the value of some other
                    column of the same conceptual row to be modified.  If
                    such a specification is made, affected columns may be
                    changed by an SNMP set PDU if the RowStatus would not
                    be equal to `active' either immediately before or after
                    processing the PDU.  In other words, if the PDU also
                    contained a varbind that would change the RowStatus
                    value, the column in question may be changed if the
                    RowStatus was not equal to `active' as the PDU was
                    received, or if the varbind sets the status to a value
                    other than 'active'.
               
               Also note that whenever any elements of a row exist, the
               RowStatus column must also exist.
               
               To summarize the effect of having a conceptual row with a
               status column having a SYNTAX clause value of RowStatus,
               consider the following state diagram:
               
                                            STATE
                 +--------------+-----------+-------------+-------------
                 |      A       |     B     |      C      |      D
                 |              |status col.|status column|
                 |status column |    is     |      is     |status column
               ACTION    |does not exist|  notReady | notInService|  is active
               --------------+--------------+-----------+-------------+-------------
               set status    |noError    ->D|inconsist- |inconsistent-|inconsistent-
               column to     |       or     |   entValue|        Value|        Value
               createAndGo   |inconsistent- |           |             |
                 |         Value|           |             |
               --------------+--------------+-----------+-------------+-------------
               set status    |noError  see 1|inconsist- |inconsistent-|inconsistent-
               column to     |       or     |   entValue|        Value|        Value
               createAndWait |wrongValue    |           |             |
               --------------+--------------+-----------+-------------+-------------
               set status    |inconsistent- |inconsist- |noError      |noError
               column to     |         Value|   entValue|             |
               active        |              |           |             |
                 |              |     or    |             |
                 |              |           |             |
                 |              |see 2   ->D|see 8     ->D|          ->D
               --------------+--------------+-----------+-------------+-------------
               set status    |inconsistent- |inconsist- |noError      |noError   ->C
               column to     |         Value|   entValue|             |
               notInService  |              |           |             |
                 |              |     or    |             |      or
                 |              |           |             |
                 |              |see 3   ->C|          ->C|see 6
               --------------+--------------+-----------+-------------+-------------
               set status    |noError       |noError    |noError      |noError   ->A
               column to     |              |           |             |      or
               destroy       |           ->A|        ->A|          ->A|see 7
               --------------+--------------+-----------+-------------+-------------
               set any other |see 4         |noError    |noError      |see 5
               column to some|              |           |             |
               value         |              |      see 1|          ->C|          ->D
               --------------+--------------+-----------+-------------+-------------
               
               (1) goto B or C, depending on information available to the
               agent.
               
               (2) if other variable bindings included in the same PDU,
               provide values for all columns which are missing but
               required, and all columns have acceptable values, then
               return noError and goto D.
               
               (3) if other variable bindings included in the same PDU,
               provide legal values for all columns which are missing but
               required, then return noError and goto C.
               
               (4) at the discretion of the agent, the return value may be
               either:
               
                    inconsistentName:  because the agent does not choose to
                    create such an instance when the corresponding
                    RowStatus instance does not exist, or
               
                    inconsistentValue:  if the supplied value is
                    inconsistent with the state of some other MIB object's
                    value, or
               
                    noError: because the agent chooses to create the
                    instance.
               
               If noError is returned, then the instance of the status
               column must also be created, and the new state is B or C,
               depending on the information available to the agent.  If
               inconsistentName or inconsistentValue is returned, the row
               remains in state A.
               
               (5) depending on the MIB definition for the column/table,
               either noError or inconsistentValue may be returned.
               
               (6) the return value can indicate one of the following
               errors:
               
                    wrongValue: because the agent does not support
                    notInService (e.g., an agent which does not support
                    createAndWait), or
               
                    inconsistentValue: because the agent is unable to take
                    the row out of service at this time, perhaps because it
                    is in use and cannot be de-activated.
               
               (7) the return value can indicate the following error:
               
                    inconsistentValue: because the agent is unable to
                    remove the row at this time, perhaps because it is in
                    use and cannot be de-activated.
               
               (8) the transition to D can fail, e.g., if the values of the
               conceptual row are inconsistent, then the error code would
               be inconsistentValue.
               
               NOTE: Other processing of (this and other varbinds of) the
               set request may result in a response other than noError
               being returned, e.g., wrongValue, noCreation, etc.
               
                                 Conceptual Row Creation
               
               There are four potential interactions when creating a
               conceptual row:  selecting an instance-identifier which is
               not in use; creating the conceptual row; initializing any
               objects for which the agent does not supply a default; and,
               making the conceptual row available for use by the managed
               device.
               
               Interaction 1: Selecting an Instance-Identifier
               
               The algorithm used to select an instance-identifier varies
               for each conceptual row.  In some cases, the instance-
               identifier is semantically significant, e.g., the
               destination address of a route, and a management station
               selects the instance-identifier according to the semantics.
               
               In other cases, the instance-identifier is used solely to
               distinguish conceptual rows, and a management station
               without specific knowledge of the conceptual row might
               examine the instances present in order to determine an
               unused instance-identifier.  (This approach may be used, but
               it is often highly sub-optimal; however, it is also a
               questionable practice for a naive management station to
               attempt conceptual row creation.)
               
               Alternately, the MIB module which defines the conceptual row
               might provide one or more objects which provide assistance
               in determining an unused instance-identifier.  For example,
               if the conceptual row is indexed by an integer-value, then
               an object having an integer-valued SYNTAX clause might be
               defined for such a purpose, allowing a management station to
               issue a management protocol retrieval operation.  In order
               to avoid unnecessary collisions between competing management
               stations, `adjacent' retrievals of this object should be
               different.
               
               Finally, the management station could select a pseudo-random
               number to use as the index.  In the event that this index
               
               was already in use and an inconsistentValue was returned in
               response to the management protocol set operation, the
               management station should simply select a new pseudo-random
               number and retry the operation.
               
               A MIB designer should choose between the two latter
               algorithms based on the size of the table (and therefore the
               efficiency of each algorithm).  For tables in which a large
               number of entries are expected, it is recommended that a MIB
               object be defined that returns an acceptable index for
               creation.  For tables with small numbers of entries, it is
               recommended that the latter pseudo-random index mechanism be
               used.
               
               Interaction 2: Creating the Conceptual Row
               
               Once an unused instance-identifier has been selected, the
               management station determines if it wishes to create and
               activate the conceptual row in one transaction or in a
               negotiated set of interactions.
               
               Interaction 2a: Creating and Activating the Conceptual Row
               
               The management station must first determine the column
               requirements, i.e., it must determine those columns for
               which it must or must not provide values.  Depending on the
               complexity of the table and the management station's
               knowledge of the agent's capabilities, this determination
               can be made locally by the management station.  Alternately,
               the management station issues a management protocol get
               operation to examine all columns in the conceptual row that
               it wishes to create.  In response, for each column, there
               are three possible outcomes:
               
                    - a value is returned, indicating that some other
                    management station has already created this conceptual