		   Perl5 SNMP Extension Module v1.8
		       for the UCD SNMP Library
		G.S. Marzot (gmarzot@baynetworks.com)

Contents:
   Introduction:
   Availability:
   Supported Platforms:
   Release Notes:
   Installation:
   Operational Description:
   Trouble Shooting:
   Acknowledments:
   History:

Introduction:

This is a Perl5 extension module which provides a full featured SNMP
client side API.  The SNMP module internals rely on the UCD SNMP
client library toolkit. The UCD SNMP library was originally based on
version 2.1.2.1 of the CMU SNMP library but has incorporated many
bugfixes and enhancements. For information on the UCD SNMP library see
the documentation provided with the UCD SNMP distribution or the
ucd-snmp project web page: http://www.ece.ucdavis.edu/ucd-snmp

(NOTE: In previous releases this module was compatible with both the
UCD and CMU SNMP libraries. Starting with Perl5/SNMP-1.7 this module
will *only* work with the UCD SNMP library due to dependence on new
features)

Availability:

The most recent release of the UCD SNMP Libray can be found at:
ftp://ftp.ece.ucdavis.edu/pub/snmp/ucd-snmp.tar.gz

The most recent release of the Perl5/SNMP module can be found at:
ftp://ftp.wellfleet.com/netman/snmp/perl5/SNMP.tar.gz
(as well as the usual perl archives, CPAN)

Supported Platforms:
	SunOS 4.1.x
	Solaris 2.x
	Linux 1.2.x, 2.0.x
	Many other UNIX variants
	Win95/NT

Release Notes:

version 1.8 is known to interoperate w/ ucd-snmp-3.5.2 (1.8a1 was
targetted at ucd-snmp-3.4). Compatibility with later versions of
ucd-snmp is not guaranteed due to the dynamic nature of free software
development :).

Installation:

build and install ucd-snmp-3.5.2

note: you should ensure that any previous ucd-snmp or cmu snmp
installation is located so that the wrong libsnmp or headers are not
used by mistake).

perl Makefile.PL
make
make test
make install

note: 'make test' requires that an agent is running to which you have
read/write access. For the ucd-snmp snmpd this may involve setting up
the snmpd.conf file with read-write access for 'private'

Operational Description:

The basic operations of the SNMP protocol are provided by this module 
through an object oriented interface for modularity and ease of use. 
The primary class is SNMP::Session which encapsulates the persistent 
aspects of a connection between the management application and the 
managed agent. Internally the class is implemented as a blessed hash 
reference. This class supplies 'get', 'getnext', 'set', 'fget', and 
'fgetnext' method calls. The methods take a variety of input argument
formats and support both syncronous and asyncronous operation through
a polymorphic API (i.e., method behaviour varies dependent on args
passed - see below).

A description of the fields which can be specified when an
SNMP::Session object is created follows:

SNMP::Session
public:
 DestHost    - default 'localhost', hostname or ip addr of SNMP agent
 Community   - default 'public', SNMP community string (used for both R/W)
 Version     - default '1', [2 (same as 2c), 2c, 3 (not implemented)]
 RemotePort  - default '161', allow remote UDP port to be overriden
 Timeout     - default '1000000', micro-seconds before retry
 Retries     - default '5', retries before failure
 RetryNoSuch - default '0', if enabled NOSUCH errors in 'get' pdus will
               be repaired, removing the varbind in error, and resent -
               undef will be returned for all NOSUCH varbinds, when set
               to '0' this feature is disabled and the entire get request
               will fail on any NOSUCH error (applies to v1 only)
 VarFormats  - default 'undef', used by 'fget[next]', holds an hash
               reference of output value formatters, (e.g., {<obj> =>
               <sub-ref>, ... }, <obj> must match the <obj> and format
               used in the get operation. A special <obj>, '*', may be
               used to apply all <obj>s, the supplied sub is called to
               translate the value to a new format. The sub is called
               passing the Varbind as the arg
 TypeFormats - default 'undef', used by 'fget[next]', holds an hash
               reference of output value formatters, (e.g., {<type> =>
               <sub-ref>, ... }, the supplied sub is called to translate
               the value to a new format, unless a VarFormat mathces first
               (e.g., $session->{TypeFormats}{INTEGER} = \&mapEnum(); 
                although this can be done more efficiently by enabling 
                $SNMP::use_enums or session creation param 'UseEnums')
 UseLongNames - defaults to the value of SNMP::use_long_names at time
               of session creation. set to non-zero to have <tags>
               for 'getnext' methods generated preferring longer Mib name
               convention (e.g., system.sysDescr vs just sysDescr)
 UseSprintValue - defaults to the value of SNMP::use_sprint_value at time
               of session creation. set to non-zero to have return values
               for 'get' and 'getnext' methods formatted with the libraries
               sprint_value function. This will result in certain data types
               being returned in non-canonical format NOTE: values returned
               with this option set may not be appropriate for 'set' operations
               (see discussion of value formats in <vars> description section)
 UseEnums    - defaults to the value of SNMP::use_enums at time of session
               creation. set to non-zero to have integer return values
               converted to enumeration identifiers if possible, these values
               will also be acceptable when supplied to 'set' operations
 ErrorStr    - read-only, holds the error message assoc. w/ last request
 ErrorNum    - read-only, holds the snmp_err or staus of last request
 ErrorInd    - read-only, holds the snmp_err_index when appropriate

private:
 DestAddr    - internal field used to hold the translated DestHost field
 SessPtr     - internal field used to cache a created session structure

methods:
 new(<fields>)   - Constructs a new SNMP::Session object. The fields are
                   passed to the contructor as a hash list
                   (e.g., $session = new SNMP::Session(DestHost => 'foo',
                   Community => 'private');), returns an object reference
                   or undef in case of error.
 update(<fields>)- Updates the SNMP::Session object with the values fields 
                   passed in as a hash list (similar to new(<fields>))
                   (WARNING! not fully implemented)
 get(<vars>[,<callback>]) 
                 - do SNMP GET, multiple <vars> formats accepted.
                   for syncronous operation <vars> will be updated
                   with value(s) and type(s) and will also return
                   retrieved value(s). If <callback> supplied method
                   will operate asyncronously
 fget(<vars>[,<callback>])    
                 - do SNMP GET like 'get' and format the values according
                   the handlers specified in $sess->{VarFormats} and
                   $sess->{TypeFormats}
 getnext(<vars>[,<callback>]) 
                 - do SNMP GETNEXT, multiple <vars> formats accepted,
                   returns retrieved value(s), <vars> passed as arguments are
                   updated to indicate next lexicographical <obj>,<iid>,<val>,
                   and <type> NOTE: simple string <vars>,(e.g., 'sysDescr.0')
                   form is not updated. If <callback> supplied method
                   will operate asyncronously
 fgetnext(<vars>[,<callback>])
                 - do SNMP GETNEXT like getnext and format the values according
                   the handlers specified in $sess->{VarFormats} and
                   $sess->{TypeFormats}
 set(<vars>[,<callback>])     
                 - do SNMP SET, multiple <vars> formats accepted.
                   the value field in all <vars> formats must be in a canonical
                   format (i.e., well known format) to ensure unambiguous
                   translation to SNMP MIB data value (see discussion of
                   canonical value format <vars> description section),
                   returns snmp_errno. If <callback> supplied method
                   will operate asyncronously
 getbulk(<non-repeaters>, <max-repeaters>, <vars>)
                 - * Not Implemented *

SNMP::TrapSession - supports all applicable fields from SNMP::Session
                    (see above)
methods:
 new(<fields>)   - Constructs a new SNMP::TrapSession object. The fields are
                   passed to the contructor as a hash list
                   (e.g., $trapsess = new SNMP::Session(DestHost => 'foo',
                   Community => 'private');), returns an object reference
                   or undef in case of error.
 trap(enterprise, agent, generic, specific, uptime, <vars>)
    $sess->trap(enterprise=>'.1.3.6.1.4.1.2021', # or 'ucdavis' [default]
                agent => '127.0.0.1', # or 'localhost',[dflt 1st intf on host]
                generic => specific,  # can be omitted if 'specific' supplied
                specific => 5,        # can be omitted if 'generic' supplied
                uptime => 1234,       # dflt to localhost uptime (0 on win32)
                [[ifIndex, 1, 1],[sysLocation, 0, "here"]]); # optional vars
                                                             # always last
 or v2 format
 trap(srcParty, dstParty, oid, uptime, <vars>)  - * Not Implemented *
    $sess->trap(srcParty => party1, 
                dstParty => party2,
                oid => 'snmpRisingAlarm',
                uptime => 1234, 
                [[ifIndex, 1, 1],[sysLocation, 0, "here"]]); # optional vars
                                                             # always last

 
Acceptable variable formats:
<vars> may be one of the following forms:

 SNMP::VarList:  - represents an array of MIB objects to get or set,
                   implemented as a blessed reference to an array of 
                   SNMP::Varbinds, (e.g., [<varbind1>, <varbind2>, ...])

 SNMP::Varbind:  - represents a single MIB object to get or set, implemented as
                   a blessed reference to a 4 element array;
                   [<obj>, <iid>, <val>, <type>].
                   <obj>  - one of the following forms:
                          1) leaf identifier (e.g., 'sysDescr') assumed to be
                             unique for practical purposes
                          2) fully qualified identifier (e.g.,
			     '.iso.org.dod.internet.mgmt.mib-2.system.sysDescr')
                          3) fully qualified, dotted-decimal, numeric OID (e.g.,
                             '.1.3.6.1.2.1.1.1')
                   <iid>  - the dotted-decimal, instance identifier. for
                            scalar MIB objects use '0'
		   <val>  - the SNMP data value retrieved from or being set
                            to the agents MIB. for (f)get(next) operations
                            <val> may have a variety of formats as determined by
                            session and package settings. However for set
                            operations the <val> format must be canonical to
                            ensure unambiguous translation. The canonical forms
                            are as follows:
	                    OBJECTID => dotted-decimal (e.g., .1.3.6.1.2.1.1.1)
			    OCTETSTR => perl scalar containing octets,
		            INTEGER => decimal signed integer (or enum),
			    NETADDR => dotted-decimal,
			    IPADDR => dotted-decimal,
			    COUNTER => decimal unsigned integer,
			    COUNTER64  => decimal unsigned integer,
			    GAUGE,  => decimal unsigned integer,
			    UINTEGER,  => decimal unsigned integer,
                            TICKS,  => decimal unsigned integer,
                            OPAQUE => perl scalar containing octets,
       			    NULL,  => perl scalar containing nothing,


                   <type> - SNMP data type (see list above), this field is
                            populated by 'get' and 'getnext' operations. In
                            some cases the programmer should populate this
                            field when passing to a 'set' operation. this
                            field need not be supplied when attribute
                            indicated by <tag> is already described by loaded
                            Mib modules. for 'set's, if a numeric OID is used
                            and the object is not currently in the loaded Mib,
                            the <type> fileds must be supplied

 simple string   - light weight form of <var> used to 'set' or 'get' a
                   single attribute without constructing an SNMP::Varbind.
                   stored in a perl scalar, has the form '<tag>.<iid>',
                   (e.g., 'sysDescr.0'). for 'set' operations the value
                   is passed as a second arg. NOTE: This argument form is
                   not updated in get[next] operations as are the other forms.

Acceptable callback formats:
<callback> may be one of the following forms:
 
 without arguments:
    \&subname
    sub { ... }
 or with arguments:
    [ \&subname, $arg1, ... ]
    [ sub { ... }, $arg1, ... ]
    [ "method", $obj, $arg1, ... ]

callback will be called when response is received or timeout
occurs. the last argument passed to callback will be a
SNMP::VarList reference. In case of timeout the last argument 
will be undef

SNMP package variables and functions:

 $SNMP::VERSION       - the current version specifier (e.g., 1.8)

 $SNMP::auto_init_mib - default '1', set to 0 to disable automatic reading
                        of the MIB upon session creation. set to non-zero
                        to call initMib at session creation which will result
                        in MIB loading according to UCD env. variables (see
                        man mib_api)

 $SNMP::verbose       - default '0', controls warning/info output of 
                        SNMP module, 0 => no output, 1 => enables warning/info
                        output from SNMP module itself (is also controlled
                        by SNMP::debugging - see below)

 $SNMP::use_long_names - default '0', set to non-zero to enable the use of
                        longer Mib identifiers. see translateObj. will also
                        influence the formatting of <tag> in varbinds returned
                        from 'getnext' operations. Can be set on a per session
                        basis (UseLongNames)

 $SNMP::use_sprint_value - default '0', set to non-zero to enable formatting of
                        response values using the snmp libraries sprint_value
                        function. can also be set on a per session basis (see
                        UseSprintValue) NOTE: returned values may not be
                        suitable for 'set' operations

 $SNMP::use_enums     - default '0',set non-zero to return values as enums and
                        allow sets using enums where appropriate. integer data
                        will still be accepted for set operations. can also be
                        set on a per session basis (see UseEnums)

 $SNMP::save_descriptions - default '0',set non-zero to have mib parser save 
                        attribute descriptions. must be set prior to mib 
                        initialization

 $SNMP::debugging     - default '0', controlls debugging output level
                        within SNMP module and libsnmp
                        1 => enables 'SNMP::verbose' (see above)
                        2 => level 1 plus snmp_set_do_debugging(1), 
                        3 => level 2 plus snmp_set_dump_packet(1)

 $SNMP::dump_packet   - default '0', set [non-]zero to independently set 
                        snmp_set_dump_packet()

 %SNMP::MIB           - a tied hash to access parsed MIB information. After 
                        the MIB has been loaded this hash allows access to  
                        to the parsed in MIB meta-data. The hash returns 
                        references to SNMP::MIB::NODE objects which represent
                        a single MIB attribute. The nodes can be fetched with
                        multiple 'key' formats - the leaf name (e.g.,sysDescr)
                        or fully/partially qualified name (e.g., 
                        system.sysDescr) or fully qualified numeric OID. The
                        returned node object supports the following fields:

        objectID      - dotted decimal fully qualified OID
        label         - leaf textual identifier (e.g., 'sysDescr')
        subID         - leaf numeric OID component of objectID (e.g., '1')
        moduleID      - textual identifier for module (e.g., 'RFC1213-MIB')
        parent        - parent node
        children      - array reference of children nodes
        nextNode      - next lexico node (BUG!does not return in lexico order)
        type          - returns application type (see getType for values)
        access        - returns ACCESS (ReadOnly, ReadWrite, WriteOnly, 
                        NoAccess, Notify, Create)
        status        - returns STATUS (Mandatory, Optional, Obsolete, 
                        Deprecated)
        syntax        - returns 'textualConvention' if defined else 'type'
        textualConvention - returns TEXTUAL-CONVENTION
        units         - returns UNITS
        hint          - returns HINT
        enums         - returns hash ref {tag => num, ...}
        description   - returns DESCRIPTION ($SNMP::save_descriptions must
                        be set prior to MIB initialization/parsing)


 &SNMP::setMib(<file>) - allows dynamic parsing of the mib and explicit
                         specification of mib file independent of enviroment
                         variables. called with no args acts like initMib,
                         loading MIBs indicated by environment variables (see
                         ucd mib_api docs). passing non-zero second arg
                         forces previous mib to be freed and replaced 
                         (note: second arg not working since freeing previous 
                          Mib is more involved than before).

 &SNMP::initMib()     - calls library init_mib function if Mib not already
                        loaded - does nothing if Mib already loaded. will
                        parse directories and load modules according to
                        environment variables described in UCD documentations.
                        (see man mib_api, MIBDIRS, MIBS, MIBFILE(S), etc.)

 &SNMP::addMibDirs(<dir>,...) - calls library add_mibdir for each directory
                        supplied. will cause directory(s) to be added to
                        internal list and made available for searching in
                        subsequent loadModules calls

 &SNMP::addMibFiles(<file>,...) - calls library read_mib function. The file(s)
                       supplied will be read and all Mib module definitions
                       contained therein will be added to internal mib tree
                       structure

 &SNMP::loadModules(<mod>,...) - calls library read_module function. The
                       module(s) supplied will be searched for in the
                       current mibdirs and and added to internal mib tree
                       structure. Passing special <mod>, 'ALL', will cause
                       all known modules to be loaded.

 &SNMP::unloadModules(<mod>,...) - *Not Implemented*

 &SNMP::translateObj(<var>[,arg]) - will convert a text obj tag to an OID and
                            vice-versa. any iid suffix is retained numerically.
                            default behaviour when converting a numeric OID
                            to text form is to return leaf indentifier only
                            (e.g.,'sysDescr') but when $SNMP::use_long_names
                            is non-zero or a non-zero second arg is supplied
                            will return longer textual identifier. If no Mib
                            is loaded when called and $SNMP::auto_init_mib is
                            enabled then the Mib will be loaded. Will return
                            'undef' upon failure.

 &SNMP::getType(<var>) - return SNMP data type for given textual identifier
                        OBJECTID, OCTETSTR, INTEGER, NETADDR, IPADDR, COUNTER
                        GAUGE, TIMETICKS, OPAQUE, or undef

 &SNMP::mapEnum(<var>) - converts integer value to enumertion tag defined
                         in Mib or converts tag to integer depending on
                         input. the function will return the corresponding 
                         integer value *or* tag for a given MIB attribute
                         and value. The function will sense which direction 
                         to perform the conversion. Various arg formats are 
                         supported
                         $val = SNMP::mapEnum($varbind); 
                         # where $varbind is SNMP::Varbind or equiv
                         # note: $varbind will be updated
                         $val = SNMP::mapEnum('ipForwarding', 'forwarding');
                         $val = SNMP::mapEnum('ipForwarding', 1);

 &SNMP::MainLoop([<timeout>, [<callback>]])  
                   - to be used with async SNMP::Session
                     calls. MainLoop must be called after initial async calls
                     so return packets from the agent will not be processed. 
                     If no args suplied this function enters an infinite loop
                     so program must be exited in a callback or externally 
                     interupted. If 

Exported SNMP utility functions 
&snmp_get() - takes args of SNMP::Session::new followed by those of 
              SNMP::Session::get

&snmp_getnext() - takes args of SNMP::Session::new followed by those of 
                  SNMP::Session::getnext

&snmp_set() - takes args of SNMP::Session::new followed by those of 
              SNMP::Session::set

&snmp_trap() - takes args of SNMP::TrapSession::new followed by those of 
               SNMP::TrapSession::trap

note: utility functions do not support async operation yet.

Trouble Shooting:

If problems occur there are number areas to look at to narrow down the
possibilities.

The first step should be to test the UCD installation independently from
the Perl5/SNMP interface. 

Try running the apps from the UCD distribution. 

Make sure your agent is running and properly configured with
read-write access for the community you are using

Ensure that your MIBs are installed and enviroment variables are set
appropriately (see man mib_api)

Be sure to remove old ucd-snmp installations and ensure headers and
libraries from old CMU installations are not being used by mistake

If the problem occurs during compilation/linking check that the snmp
library being linked is actually the UCD library (there have been name
conflicts with existing snmp libs). 

Also check that the header files are correct and up to date. 

Sometimes compiling the UCD snmp library with
'position-independent-code' enabled is required (HPUX specifically).

if you cannot resolve the problem you can email me at
gmarzot@baynetworks.com and/or ucd-snmp-coders@ece.ucdavis.edu.
and maybe I can help.

please give sufficient information to analyze the problem (OS type,
versions for OS/Perl/UCD/compiler, complete error output, etc.)

Acknowledments:

Many thanks to all those who supplied patches, suggestions and
feedback. 

Wes Hardaker and the ucd-coders
Dave Perkins
Marcel Wiget
David Blackburn
John Stofell
Gary Hayward
Claire Harrison
Achim Bohnet
Doug Kingston
Jacques Vidrine
Carl Jacobsen
Wayne Marquette
Scott Schumate
Perl5 Porters

Apologies to any/all who's patch/feature/request was not mentioned or
included - most likely it was lost when paying work intruded on my
fun. Please try again if you do not see a desired feature. This may
actually turn out to be a decent package with such excellent help and
the fact that I have more time to work on it than in the past.

bugs, comments, questions to gmarzot@baynetworks.com

------
History:

Bugs fixed and changes in 1.8

1) added async API (async api should be considered beta -
   potential changes are most likely in the event loop integration
   area - would like to integrate with Event.pm)

2) added trap generation API (implemented v1 traps only for now)

3) added and exported non-OO utility API (snmp_get, snmp_set, etc.)

4) added $SNMP::debugging to dynmically control libsnmp debugging output

5) added $SNMP::save_descriptions to control libsnmp parsing/saving 
   of MIB descriptions

6) added $SNMP::dump_packet to control libsnmp packet dumping

7) implemented the SNMP::mapEnum function (thanks to Wayne Marquette)

8) officially added(documented) tied %SNMP::MIB hash to allow access
   to parsed MIB meta-data (new support for textualConvention and syntax)

9) fixed bug related to AUTOLOAD recursion

10) fixed bug with SNMP::use_enums so 'set' (and trap) should now accept
   enums as input values

11) fixed bug with fget[next] - formatted values are supplied as return
    values as well as within args passed

12) fixed Makefile to link with -kstat on solaris        

13) fixed bug when handling noSuchName returns for getnext calls with 
    varbinds w/ no iid supplied (__get_label_iid should not use the 
    FAIL_ON_NULL_IID flag)

14) fixed bug with uninitialized sprintval_flag

15) fixed bug when no val is passed to SNMP::Session::set - now
    will not core or complain about uninitialized data

16) fixed bug with __translate_appl_type in case of NULL or empty string

17) eliminated the use of strtoul for portability - use sscanf(,"%lu",)

18) getType() supports all tag formats now

19) fixed bug when setting values of type OBJID (thanks Scott Schumate)

20) *WARNING* RetryNoSuch in session creation had a bug which prevented
    it from being disbaled. It now defaults to being disabled - this may
    break code *WARNING*


Bugs fixed and changes in 1.7

1) fixed seg fault on use of unknown/unparsed attribute in Varbind or
   passed to translateObj

2) fixed truncation of last char of attribute name in translateObj

3) handles variable args to setMib without complaint

4) added SNMP::getType to query data type of a given attribute and
   extended Varbind structure to return type wherever possible

5) added RemotePort to SNMP::Session initialation list to allow override
   of port 161

6) removed noisy announcement of mib parse success unless verbose is set

	       *WARNING*  *this may break existing scripts*
7) changed return format for IpAddress and ObjID data types - these are
   now always returned as dotted decimal strings as opposed to the
   packed binary forms in 1.6
	       *WARNING*  *this may break existing scripts*

8) Session now sets ErrorInd (e.g., $session->{ErrorInd}) where appropriate

9) Support for ucd-snmp-3.2 (and greater) style of Mib loading

10) Fully qualified attriubute names and numeric OIDs are now valid <obj>
   defintions.

11) Numeric OIDs can be used even if they have not been parsed in the
    current Mib - Mib loading is now optional

12) Support for Win32 perl

13) Updated docs and examples

14) Reworked/extended the test harness to use the perl t/* facility
    (thanks to jfs@fluent.com)

15) fixed up error handling to be more consistent with library and more
    useful in general. Now returns both library API errors and snmp
    protocol error numbers and strings.

16) added per object and per type formatting of returned values - more
    control of value formatting with UseEnums and UseSprintValue
