rfc2573.txt

RFC 的详细文档！

Levi, et al.                Standards Track                    [Page 17]

RFC 2573                   SNMP Applications                  April 1999


     -  The pduVersion indicates the version of the PDU in the received
        message.

     -  The PDU is the value from the received message.

     -  The maxSizeResponseScopedPDU is the maximum allowable size of a
        ScopedPDU containing a Response PDU (based on the maximum
        message size that the originator of the message can accept).

     -  If the message contains an Unconfirmed-Class PDU, the
        stateReference is undefined and unused.  Otherwise, the
        stateReference is a value which references cached information
        about the notification.  This value must be returned to the
        Dispatcher in order to generate a response.

   When an Unconfirmed-Class PDU is delivered to a notification receiver
   application, it first extracts the SNMP operation type, request-id,
   error-status, error-index, and variable-bindings from the PDU.  After
   this, processing depends on the particular implementation.

   When a Confirmed-Class PDU is received, the notification receiver
   application follows the following procedure:

   (1)  The PDU type, request-id, error-status, error-index, and
        variable-bindings are extracted from the PDU.

   (2)  A Response-Class PDU is constructed using the extracted
        request-id and variable-bindings, and with error-status and
        error-index both set to 0.

   (3)  The Dispatcher is called to generate a response message using
        the returnResponsePdu abstract service interface.  Parameters
        are:

     -  The messageProcessingModel is the value from the processPdu
        call.

     -  The securityModel is the value from the processPdu call.

     -  The securityName is the value from the processPdu call.

     -  The securityLevel is the value from the processPdu call.

     -  The contextEngineID is the value from the processPdu call.

     -  The contextName is the value from the processPdu call.

     -  The pduVersion indicates the version of the PDU to be returned.



Levi, et al.                Standards Track                    [Page 18]

RFC 2573                   SNMP Applications                  April 1999


     -  The PDU is the result generated in step (2) above.

     -  The maxSizeResponseScopedPDU is a local value indicating the
        maximum size of a ScopedPDU that the application can accept.

     -  The stateReference is the value from the processPdu call.

     -  The statusInformation indicates that no error occurred and that
        a response should be generated.

3.5.  Proxy Forwarder Applications

   A proxy forwarder application deals with forwarding SNMP messages.
   There are four basic types of messages which a proxy forwarder
   application may need to forward.  These are grouped according to the
   class of PDU type contained in a message.  The four basic types of
   messages are:

     -  Those containing Read-Class or Write-Class PDU types (for
        example, Get, GetNext, GetBulk, and Set PDU types).  These deal
        with requesting or modifying information located within a
        particular context.

     -  Those containing Notification-Class PDU types (for example,
        SNMPv2-Trap and Inform PDU types).  These deal with
        notifications concerning information located within a particular
        context.

     -  Those containing a Response-Class PDU type.  Forwarding of
        Response PDUs always occurs as a result of receiving a response
        to a previously forwarded message.

     -  Those containing Internal-Class PDU types (for example, a Report
        PDU).  Forwarding of Internal-Class PDU types always occurs as a
        result of receiving an Internal-Class PDU in response to a
        previously forwarded message.

   For the first type, the proxy forwarder's role is to deliver a
   request for management information to an SNMP engine which is
   "closer" or "downstream in the path" to the SNMP engine which has
   access to that information, and to deliver the response containing
   the information back to the SNMP engine from which the request was
   received.  The context information in a request is used to determine
   which SNMP engine has access to the requested information, and this
   is used to determine where and how to forward the request.






Levi, et al.                Standards Track                    [Page 19]

RFC 2573                   SNMP Applications                  April 1999


   For the second type, the proxy forwarder's role is to determine which
   SNMP engines should receive notifications about management
   information from a particular location.  The context information in a
   notification message determines the location to which the information
   contained in the notification applies.  This is used to determine
   which SNMP engines should receive notification about this
   information.

   For the third type, the proxy forwarder's role is to determine which
   previously forwarded request or notification (if any) the response
   matches, and to forward the response back to the initiator of the
   request or notification.

   For the fourth type, the proxy forwarder's role is to determine which
   previously forwarded request or notification (if any) the Internal-
   Class PDU matches, and to forward the Internal-Class PDU back to the
   initiator of the request or notification.

   When forwarding messages, a proxy forwarder application must perform
   a translation of incoming management target information into outgoing
   management target information.  How this translation is performed is
   implementation specific.  In many cases, this will be driven by a
   preconfigured translation table.  If a proxy forwarder application
   makes the contents of this table SNMP manageable, it MUST use the
   SNMP-PROXY-MIB module defined in this document.

3.5.1.  Request Forwarding

   There are two phases for request forwarding.  First, the incoming
   request needs to be passed through the proxy application.  Then, the
   resulting response needs to be passed back.  These phases are
   described in the following two sections.

3.5.1.1.  Processing an Incoming Request

   A proxy forwarder application that wishes to forward request messages
   must first register with the Dispatcher using the
   registerContextEngineID abstract service interface.  The proxy
   forwarder must register each contextEngineID for which it wishes to
   forward messages, as well as for each pduType.  Note that as the
   configuration of a proxy forwarder is changed, the particular
   contextEngineID values for which it is forwarding may change.  The
   proxy forwarder should call the registerContextEngineID and
   unregisterContextEngineID abstract service interfaces as needed to
   reflect its current configuration.






Levi, et al.                Standards Track                    [Page 20]

RFC 2573                   SNMP Applications                  April 1999


   A proxy forwarder application should never attempt to register a
   value of contextEngineID which is equal to the snmpEngineID of the
   SNMP engine to which the proxy forwarder is associated.

   Once the proxy forwarder has registered for the appropriate
   contextEngineID values, it can start processing messages.  The
   following procedure is used:

   (1)  A message is received using the processPdu abstract service
        interface.  The incoming management target information received
        from the processPdu interface is translated into outgoing
        management target information.  Note that this translation may
        vary for different values of contextEngineID and/or contextName.
        The translation should result in a single management target.

   (2)  If appropriate outgoing management target information cannot be
        found, the proxy forwarder increments the snmpProxyDrops counter
        [RFC1907], and then calls the Dispatcher using the
        returnResponsePdu abstract service interface.  Parameters are:

     -  The messageProcessingModel is the value from the processPdu
        call.

     -  The securityModel is the value from the processPdu call.

     -  The securityName is the value from the processPdu call.

     -  The securityLevel is the value from the processPdu call.

     -  The contextEngineID is the value from the processPdu call.

     -  The contextName is the value from the processPdu call.

     -  The pduVersion is the value from the processPdu call.

     -  The PDU is an undefined value.

     -  The maxSizeResponseScopedPDU is a local value indicating the
        maximum size of a ScopedPDU that the application can accept.

     -  The stateReference is the value from the processPdu call.

     -  The statusInformation indicates that an error occurred and
        includes the OID and value of the snmpProxyDrops object.

        Processing of the message stops at this point.  Otherwise,





Levi, et al.                Standards Track                    [Page 21]

RFC 2573                   SNMP Applications                  April 1999


   (3)  A new PDU is constructed.  A unique value of request-id should
        be used in the new PDU (this value will enable a subsequent
        response message to be correlated with this request).  The
        remainder of the new PDU is identical to the received PDU,
        unless the incoming SNMP version and the outgoing SNMP version
        support different PDU versions, in which case the proxy
        forwarder may need to perform a translation on the PDU (A method
        for performing such a translation is described in [COEX].)

   (4)  The proxy forwarder calls the Dispatcher to generate the
        forwarded message, using the sendPdu abstract service interface.
        The parameters are:

     -  The transportDomain is that of the outgoing management target.

     -  The transportAddress is that of the outgoing management target.

     -  The messageProcessingModel is that of the outgoing management
        target.

     -  The securityModel is that of the outgoing management target.

     -  The securityName is that of the outgoing management target.

     -  The securityLevel is that of the outgoing management target.

     -  The contextEngineID is the value originally received.

     -  The contextName is the value originally received.

     -  The pduVersion is the version of the PDU to be sent.

     -  The PDU is the value constructed in step (3) above.

     -  The expectResponse argument indicates that a response is
        expected.  If the sendPdu call is unsuccessful, the proxy
        forwarder performs the steps described in (2) above.  Otherwise:

   (5)  The proxy forwarder caches the following information in order to
        match an incoming response to the forwarded request:

     -  The sendPduHandle returned from the call to sendPdu,

     -  The request-id from the received PDU.

     -  the contextEngineID,

     -  the contextName,



Levi, et al.                Standards Track                    [Page 22]

RFC 2573                   SNMP Applications                  April 1999


     -  the stateReference,

     -  the incoming management target information,

     -  the outgoing management information,

     -  any other information needed to match an incoming response to
        the forwarded request.

        If this information cannot be cached (possibly due to a lack of
        resources), the proxy forwarder performs the steps described in
        (2) above.  Otherwise:

   (6)  Processing of the request stops until a response to the
        forwarded request is received, or until an appropriate time
        interval has expired.  If this time interval expires before a
        response has been received, the cached information about this
        request is removed.

3.5.1.2.  Processing an Incoming Response

   A proxy forwarder follows the following procedure when an incoming
   response is received:

   (1)  The incoming response is received using the processResponsePdu
        interface.  The proxy forwarder uses the received parameters to
        locate an entry in its cache of pending forwarded requests.
        This is done by matching the received parameters with the cached
        values of sendPduHandle, contextEngineID, contextName, outgoing
        management target information, and the request-id contained in