Network Working Group                                       G. Carpenter
Request for Comments: 1228                                     B. Wijnen
                                  T.J. Watson Research Center, IBM Corp.
                                                                May 1991

                   Simple Network Management Protocol
                     Distributed Program Interface

Status of this Memo

   This RFC describes a protocol that International Business Machines
   Corporation (IBM) has been implementing in most of its SNMP agents to
   allow dynamic extension of supported MIBs.  This is an Experimental
   Protocol for the Internet community.  Discussion and suggestions for
   improvement are requested.  Please refer to the current edition of
   the "IAB Official Protocol Standards" for the standardization state
   and status of this protocol.  Distribution of this memo is unlimited.


   The Simple Network Management Protocol (SNMP) [1] Distributed Program
   Interface (DPI) is an extension to SNMP agents that permits end-users
   to dynamically add, delete or replace management variables in the
   local Management Information Base without requiring recompilation of
   the SNMP agent.  This is achieved by writing a so-called sub-agent
   that communicates with the agent via the SNMP-DPI.

   For the author of a sub-agent, the SNMP-DPI eliminates the need to
   know the details of ASN.1 [2] or SNMP PDU (Protocol Data Unit)
   encoding/decoding [1, 3].

   This protocol has been in use within IBM since 1989 and is included
   in the SNMP agents for VM, MVS and OS/2.

   Potentially useful sample sub-agent code and implementation examples
   are available for anonymous FTP from the University of Toronto.


   The Simple Network Management Protocol [1] defines a protocol that
   permits operations on a collection of variables.  This set of
   variables is called the Management Information Base (MIB) and a core
   set of variables has previously been defined [4, 5]; however, the
   design of the MIB makes provision for extension of this core set.
   Thus, an enterprise or individual can define variables of their own
   which represent information of use to them.  An example of a

Carpenter & Wijnen                                              [Page 1]

RFC 1228                        SNMP-DPI                        May 1991

   potentially interesting variable which is not in the core MIB would
   be CPU utilization (percent busy).  Unfortunately, conventional SNMP
   agent implementations provide no means for an end-user to make
   available new variables.

   The SNMP DPI addresses this issue by providing a light-weight
   mechanism by which a process can register the existence of a MIB
   variable with the SNMP agent.  When requests for the variable are
   received by the SNMP agent, it will pass the query on to the process
   acting as a sub-agent.  This sub-agent then returns an appropriate
   answer to the SNMP agent.  The SNMP agent eventually packages an SNMP
   response packet and sends the answer back to the remote network
   management station that initiated the request.

   None of the remote network management stations have any knowledge
   that the SNMP agent calls on other processes to obtain an answer.  As
   far as they can tell, there is only one network management
   application running on the host.



   Communication between the SNMP Agent and its clients (sub-agents)
   takes place over a stream connection.  This is typically a TCP
   connection, but other stream-oriented transport mechanisms can be
   used.  As an example, the VM SNMP agent allows DPI connections over
   IUCV (Inter-User Communications Vehicle) [6, 7].  Other than the
   connection establishment procedure, the protocol used is identical in
   these environments.


   Regardless of the connection-oriented transport mechanism used, after
   establishing a connection to the SNMP agent, the sub-agent registers
   the set of variables it supports.  Finally, when all the variable
   classes have been registered, the sub-agent then waits for requests
   from the SNMP agent or generates traps as required.


   There are three requests that can be initiated by the SNMP agent:
   GET, GET-NEXT and SET.  These correspond directly to the three SNMP
   requests that a network management station can make.  The sub-agent
   responds to a request with a RESPONSE packet.

   There are currently two requests that can be initiated by a sub-
   agent: REGISTER and TRAP.

Carpenter & Wijnen                                              [Page 2]

RFC 1228                        SNMP-DPI                        May 1991


|  SNMP Network                   |
|  Management Station             |
|                                 |
|  SNMP Protocol                  |
      A      | Get         A
      |      | GetNext     |  GetResponse
 Trap |      | Set         |
      |      V             |
*---------------------------------*            *----------------------*
|     SNMP Protocol               |            |   DPI Interface      |
|---------------------------------|  Reply     |    *-----------------|
|                        |        |<-----------|    |                 |
|     SNMP Agent         |        |            |    |   Client        |
|     A      *-----------+->      | MIB query  |    |                 |
|     |      | Get/Set   |        |----------->|    |     or          |
| Trap|      | info      |  SNMP  |            |    |                 |
|-----+------+-------*   |        |  trap      |    |   SNMP          |
|     |      V       |   |  DPI   |<-----------|    |   Sub-Agent     |
| TCP/IP layers,     |   |        |            |    |                 |
| Kernel             |   |        |<-----------|    |                 |
*---------------------------------*  Register  *----------------------*

Figure 1. SNMP DPI overview

Remarks for Figure 1:

   o   The SNMP agent communicates with the SNMP manager via the
       standard SNMP protocol.
   o   The SNMP agent communicates with the TCP/IP layers and kernel
       (operating system) in an implementation-dependent manner.  It
       potentially implements the standard MIB view in this way.
   o   An SNMP sub-agent, running as a separate process (potentially
       even on another machine), can register objects with the SNMP
   o   The SNMP agent will decode SNMP Packets.  If such a packet
       contains a Get/GetNext or Set request for an object registered
       by a sub-agent, it will send the request to the sub-agent via
       the corresponding query packet.
   o   The SNMP sub-agent sends responses back via a RESPONSE packet.
   o   The SNMP agent then encodes the reply into an SNMP packet and
       sends it back to the requesting SN