CentOS 7.0 - man page for snmp (centos section 3)

Linux & Unix Commands - Search Man Pages

Man Page or Keyword Search:   man
Select Man Page Set:       apropos Keyword Search (sections above)

SNMP(3) 		       User Contributed Perl Documentation			  SNMP(3)

       SNMP - The Perl5 'SNMP' Extension Module for the Net-SNMP SNMP package.

	use SNMP;
	$sess = new SNMP::Session(DestHost => localhost, Community => public);
	$val = $sess->get('sysDescr.0');
	$vars = new SNMP::VarList([sysDescr,0], [sysContact,0], [sysLocation,0]);
	@vals = $sess->get($vars);
	$vb = new SNMP::Varbind();
	do {
	   $val = $sess->getnext($vb);
	   print "@{$vb}\n";
	} until ($sess->{ErrorNum});
	$SNMP::save_descriptions = 1;
	SNMP::initMib(); # assuming mib is not already loaded
	print "$SNMP::MIB{sysDescr}{description}\n";

       Note: The perl SNMP 5.0 module which comes with net-snmp 5.0 and higher is different than
       previous versions in a number of ways.  Most importantly, it behaves like a proper net-
       snmp application and calls init_snmp properly, which means it will read configuration
       files and use those defaults where appropriate automatically parse MIB files, etc.  This
       will likely affect your perl applications if you have, for instance, default values set up
       in your snmp.conf file (as the perl module will now make use of those defaults).  The
       documentation, however, has sadly not been updated yet (aside from this note), nor is the
       read_config default usage implementation fully complete.

       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 synchronous
       and asynchronous operation through a polymorphic API (i.e., method behaviour varies
       dependent on args passed - see below).

       $sess = new SNMP::Session(DestHost => 'host', ...)

       The following arguments may be passed to new as a hash.

   Basic Options
	   Hostname or IP address of the SNMP agent you want to talk to.  Specified in Net-SNMP
	   formatted agent addresses.  These addresses typically look like one of the following:


	   Defaults to 'localhost'.

	   SNMP version to use.

	   The default is taken from library configuration - probably 3 [1, 2 (same as 2c), 2c,

	   The number of micro-seconds to wait before resending a request.

	   The default is '1000000'

	   The number of times to retry a request.

	   The default is '5'

	   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)

	   The default is '0'.

   SNMPv3/TLS Options
	   Our X.509 identity to use, which should either be a fingerprint or the filename that
	   holds the certificate.

	   The remote server's identity to connect to, specified as eihter a fingerprint or a
	   file name.  Either this must be specified, or the hostname below along with a trust

	   The remote server's hostname that is expected.  If their certificate was signed by a
	   CA then their hostname presented in the certificate must match this value or the
	   connection fails to be established (to avoid man-in-the-middle attacks).

	   A trusted certificate to use a trust anchor (like a CA certificate) for verifying a
	   remote server's certificate.  If a CA certificate is used to validate a certificate
	   then the TheirHostname parameter must also be specified to ensure their presente
	   hostname in the certificate matches.

   SNMPv3/USM Options
	   The SNMPv3 security name to use (most for SNMPv3 with USM).

	   The default is 'initial'.

	   The SNMPv3 security level to use [noAuthNoPriv, authNoPriv, authPriv] (v3)

	   The default is 'noAuthNoPriv'.

	   The SNMPv3 security engineID to use (if the snmpv3 security model needs it; for
	   example USM).

	   The default is <none>, security engineID and it will be probed if not supplied (v3)

	   The SNMPv3 context engineID to use.

	   The default is the <none> and will be set either to the SecEngineId value if set or
	   discovered or will be discovered in other ways if using TLS (RFC5343 based discovery).

	   The SNMPv3 context name to use.

	   The default is '' (an empty string)

	   The SNMPv3/USM authentication protocol to use [MD5, SHA].

	   The default is 'MD5'.

	   The SNMPv3/USM authentication passphrase to use.

	   default <none>, authentication passphrase

	   The SNMPv3/USM privacy protocol to use [DES, AES].

	   The default is 'DES'.

	   The SNMPv3/USM privacy passphrase to use.

	   default <none>, privacy passphrase (v3)

	   Directly specified SNMPv3 USM user keys (used if you want to specify the keys instead
	   of deriving them from a password as above).

   SNMPv1 and SNMPv2c Options
	   For SNMPv1 and SNMPv2c, the clear-text community name to use.

	   The default is 'public'.

   Other Configuration Options
	   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

	   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.,
	   $sess->{TypeFormats}{INTEGER} = \&mapEnum(); although this can be done more
	   efficiently by enabling $SNMP::use_enums or session creation param 'UseEnums')

	   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)

	   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 snprint_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)

	   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

	   defaults to the value of SNMP::use_numeric at time of session creation. set to non-
	   zero to have <tags> for get methods returned as numeric OID's rather than
	   descriptions.  UseLongNames will be set so that the full OID is returned to the

	   defaults to the value of SNMP::best_guess at time of session creation. this setting
	   controls how <tags> are parsed.  setting to 0 causes a regular lookup.  setting to 1
	   causes a regular expression match (defined as -Ib in snmpcmd) and setting to 2 causes
	   a random access lookup (defined as -IR in snmpcmd).

	   defaults to the value of SNMP::non_increasing at time of session creation. this
	   setting controls if a non-increasing OID during bulkwalk will causes an error. setting
	   to 0 causes the default behaviour (which may, in very badly performing agents, result
	   in a never-ending loop).  setting to 1 causes an error (OID not increasing) when this
	   error occur.

	   read-only, holds the error message assoc. w/ last request

	   read-only, holds the snmp_err or staus of last request

	   read-only, holds the snmp_err_index when appropriate

       Private variables:

	   internal field used to hold the translated DestHost field

	   internal field used to cache a created session structure

	   Obsolete.  Please use the DestHost specifier to indicate the hostname and port
	   combination instead of this paramet.

   SNMP::Session methods
	   Updates the SNMP::Session object with the values fields passed in as a hash list
	   (similar to new(<fields>)) (WARNING! not fully implemented)

       $sess->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 asynchronously

       $sess->fget(<vars> [,<callback>])
	   do SNMP GET like 'get' and format the values according the handlers specified in
	   $sess->{VarFormats} and $sess->{TypeFormats}

       $sess->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 asynchronously

       $sess->fgetnext(<vars> [,<callback>])
	   do SNMP GETNEXT like getnext and format the values according the handlers specified in
	   $sess->{VarFormats} and $sess->{TypeFormats}

       $sess->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

       $sess->getbulk(<non-repeaters>, <max-repeaters>, <vars>)
	   do an SNMP GETBULK, from the list of Varbinds, the single next lexico instance is
	   fetched for the first n Varbinds as defined by <non-repeaters>. For remaining
	   Varbinds, the m lexico instances are retrieved each of the remaining Varbinds, where m
	   is <max-repeaters>.

       $sess->bulkwalk(<non-repeaters>, <max-repeaters>, <vars> [,<callback>])
	   Do a "bulkwalk" of the list of Varbinds.  This is done by sending a GETBULK request
	   (see getbulk() above) for the Varbinds.  For each requested variable, the response is
	   examined to see if the next lexico instance has left the requested sub-tree.  Any
	   further instances returned for this variable are ignored, and the walk for that sub-
	   tree is considered complete.

	   If any sub-trees were not completed when the end of the responses is reached, another
	   request is composed, consisting of the remaining variables.	This process is repeated
	   until all sub-trees have been completed, or too many packets have been exchanged (to
	   avoid loops).

	   The bulkwalk() method returns an array containing an array of Varbinds, one for each
	   requested variable, in the order of the variable requests.  Upon error, bulkwalk()
	   returns undef and sets $sess->ErrorStr and $sess->ErrorNum.	If a callback is
	   supplied, bulkwalk() returns the SNMP request id, and returns immediately.  The
	   callback will be called with the supplied argument list and the returned variables

	   Note: Because the client must "discover" that the tree is complete by comparing the
	   returned variables with those that were requested, there is a potential "gotcha" when
	   using the max-repeaters value.  Consider the following code to print a list of
	   interfaces and byte counts:

	       $numInts = $sess->get('ifNumber.0');
	       ($desc, $in, $out) = $sess->bulkwalk(0, $numInts,
			     [['ifDescr'], ['ifInOctets'], ['ifOutOctets']]);

	       for $i (0..($numInts - 1)) {
		   printf "Interface %4s: %s inOctets, %s outOctets\n",
			     $$desc[$i]->val, $$in[$i]->val, $$out[$i]->val;

	   This code will produce *two* requests to the agent -- the first to get the interface
	   values, and the second to discover that all the information was in the first packet.
	   To get around this, use '$numInts + 1' for the max_repeaters value.	This asks the
	   agent to include one additional (unrelated) variable that signals the end of the sub-
	   tree, allowing bulkwalk() to determine that the request is complete.

       $results = $sess->gettable(<TABLE OID>, <OPTIONgt)
	   This will retrieve an entire table of data and return a hash reference to that data.
	   The returned hash reference will have indexes of the OID suffixes for the index data
	   as the key.	The value for each entry will be another hash containing the data for a
	   given row.  The keys to that hash will be the column names, and the values will be the



	     use SNMP;
	     use Data::Dumper;

	     my $s = new SNMP::Session(DestHost => 'localhost');

	     print Dumper($s->gettable('ifTable'));

	   On my machine produces:

	     $VAR1 = {
		       '6' => {
				'ifMtu' => '1500',
				'ifPhysAddress' => 'PV',
				# ...
				'ifInUnknownProtos' => '0'
		       '4' => {
				'ifMtu' => '1480',
				'ifPhysAddress' => '',
				# ...
				'ifInUnknownProtos' => '0'
		       # ...

	   By default, it will try to do as optimized retrieval as possible.  It'll request
	   multiple columns at once, and use GETBULK if possible.  A few options may be specified
	   by passing in an OPTIONS hash containing various parameters:

	   noindexes => 1
	       Instructs the code not to parse the indexes and place the results in the second
	       hash.  If you don't need the index data, this will be faster.

	   columns => [ colname1, ... ]
	       This specifies which columns to collect.  By default, it will try to collect all
	       the columns defined in the MIB table.

	   repeat => COUNT
	       Specifies a GETBULK repeat COUNT.  IE, it will request this many varbinds back per
	       column when using the GETBULK operation.  Shortening this will mean smaller
	       packets which may help going through some systems.  By default, this value is
	       calculated and attempts to guess at what will fit all the results into 1000 bytes.
	       This calculation is fairly safe, hopefully, but you can either raise or lower the
	       number using this option if desired.  In lossy networks, you want to make sure
	       that the packets don't get fragmented and lowering this value is one way to help

	   nogetbulk => 1
	       Force the use of GETNEXT rather than GETBULK.  (always true for SNMPv1, as it
	       doesn't have GETBULK anyway).  Some agents are great implementers of GETBULK and
	       this allows you to force the use of GETNEXT operations instead.

	   callback => \&subroutine
	   callback => [\&subroutine, optarg1, optarg2, ...]
	       If a callback is specified, gettable will return quickly without returning
	       results.  When the results are finally retrieved the callback subroutine will be
	       called (see the other sections defining callback behaviour and how to make use of
	       SNMP::MainLoop which is required fro this to work).  An additional argument of the
	       normal hash result will be added to the callback subroutine arguments.

	       Note 1: internally, the gettable function uses it's own callbacks which are passed
	       to getnext/getbulk as appropriate.

	       Note 2: callback support is only available in the SNMP module version 5.04 and
	       above.  To test for this in code intending to support both versions prior to 5.04
	       and 5.04 and up, the following should work:

		 if ($response = $sess->gettable('ifTable', callback => \&my_sub)) {
		     # got a response, gettable doesn't support callback
		     $no_mainloop = 1;

	       Deciding on whether to use SNMP::MainLoop is left as an exercise to the reader
	       since it depends on whether your code uses other callbacks as well.

       $sess = new SNMP::Session(DestHost => 'host', ...)

       supports all applicable fields from SNMP::Session (see above)

   SNMP::TrapSession methods
       $sess->trap(enterprise, agent, generic, specific, uptime, <vars>)
	       $sess->trap(enterprise=>'.', # or 'ucdavis' [default]
			   agent => '', # 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

       trap(oid, uptime, <vars>) - v2 format
	       $sess->trap(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:

	   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>, ...])

	   represents a single MIB object to get or set, implemented as a blessed reference to a
	   4 element array; [<obj>, <iid>, <val>, <type>].

	       one of the following forms:

	       1)  leaf identifier (e.g., 'sysDescr') assumed to be unique for practical purposes

	       2)  fully qualified identifier (e.g.,

	       3)  fully qualified, dotted-decimal, numeric OID (e.g., '.')

	       the dotted-decimal, instance identifier. for scalar MIB objects use '0'

	       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:

		   dotted-decimal (e.g., .

		   perl scalar containing octets

		   decimal signed integer (or enum)



		   decimal unsigned integer

		   decimal unsigned integer

		   decimal unsigned integer

		   decimal unsigned integer

		   decimal unsigned integer

		   perl scalar containing octets

		   perl scalar containing nothing

	       SNMP data type (see list above), this field is populated by 'get' and 'getnext'
	       operations. In some cases the programmer needs to populate this field when passing
	       to a 'set' operation. this field need not be supplied when the 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> field 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
	   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::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 supplied
	   this function enters an infinite loop so program must be exited in a callback or
	   externally interrupted. If <timeout(sic)

	   This function, when called from an SNMP::MainLoop() callback function, will cause the
	   current SNMP::MainLoop() to return after the callback is completed.	finish() can be
	   used to terminate an otherwise-infinite MainLoop.  A new MainLoop() instance can then
	   be started to handle further requests.

SNMP package variables and functions
	   the current version specifier (e.g., 3.1.0)

	   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 Net-SNMP env. variables (see man mib_api)

	   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)

	   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)

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

	   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)

	   default to '0',set to non-zero to have <tags> for 'get' methods returned as numeric
	   OID's rather than descriptions.  UseLongNames will be set so that the entire OID will
	   be returned.  Set on a per-session basis (see UseNumeric).

	   default '0'.  This setting controls how <tags> are parsed.  Setting to 0 causes a
	   regular lookup.  Setting to 1 causes a regular expression match (defined as -Ib in
	   snmpcmd) and setting to 2 causes a random access lookup (defined as -IR in snmpcmd).
	   Can also be set on a per session basis (see BestGuess)

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

	   default '0', controls 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)

	   default '0', set [non-]zero to independently set snmp_set_dump_packet()

	   Allows to register one or more debug tokens, just like the -D option of snmpd.  Each
	   debug token enables a group of debug statements. An example:

       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 structure of the MIB (i.e., schema)).
       The hash returns blessed 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:

	   dotted decimal fully qualified OID

	   leaf textual identifier (e.g., 'sysDescr')

	   leaf numeric OID component of objectID (e.g., '1')

	   textual identifier for module (e.g., 'RFC1213-MIB')

	   parent node

	   array reference of children nodes

	   next lexico node (BUG!does not return in lexico order)

	   returns application type (see getType for values)

	   returns ACCESS (ReadOnly, ReadWrite, WriteOnly, NoAccess, Notify, Create)

	   returns STATUS (Mandatory, Optional, Obsolete, Deprecated)

	   returns 'textualConvention' if defined else 'type'



	   returns UNITS

	   returns HINT

	   returns hash ref {tag => num, ...}

	   returns array ref of hash ref [{low => num, high => num}, ...]

	   returns DESCRIPTION ($SNMP::save_descriptions must be set prior to MIB

	   returns the REFERENCE clause

	   returns the objects in the INDEX clause

	   returns true if the last object in the INDEX is IMPLIED

MIB Functions
	   allows dynamic parsing of the mib and explicit specification of mib file independent
	   of environment variables. called with no args acts like initMib, loading MIBs
	   indicated by environment variables (see Net-SNMP 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).

	   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 Net-SNMP documentations.  (see man mib_api, MIBDIRS, MIBS,
	   MIBFILE(S), etc.)

	   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 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

	   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.

	   *Not Implemented*

	   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 identifier only (e.g.,'sysDescr') but when $SNMP::use_long_names is non-
	   zero or a non-zero second arg is supplied it will return a longer textual identifier.
	   An optional third argument of non-zero will cause the module name to be prepended to
	   the text name (e.g.	'SNMPv2-MIB::sysDescr').  When converting a text obj, the
	   $SNMP::best_guess option is used.  If no Mib is loaded when called and
	   $SNMP::auto_init_mib is enabled then the Mib will be loaded. Will return 'undef' upon

	   return SNMP data type for given textual identifier OBJECTID, OCTETSTR, INTEGER,

	   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);

Exported SNMP utility functions
       Note: utility functions do not support async operation yet.

	   takes args of SNMP::Session::new followed by those of SNMP::Session::get

	   takes args of SNMP::Session::new followed by those of SNMP::Session::getnext

	   takes args of SNMP::Session::new followed by those of SNMP::Session::set

	   takes args of SNMP::TrapSession::new followed by those of SNMP::TrapSession::trap

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 Net-SNMP installation independently from the Perl5
       SNMP interface.

       Try running the apps from the Net-SNMP distribution.

       Make sure your agent (snmpd) 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 net-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 Net-SNMP 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 Net-SNMP library with 'position-independent-code' enabled is
       required (HPUX specifically).

       If you cannot resolve the problem you can post to comp.lang.perl.modules or

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

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

	Joe Marzot (the original author)
	Wes Hardaker and the net-snmp-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
	Michael Slifcak
	Srivathsan Srinivasagopalan
	Bill Fenner
	Jef Peeraer
	Daniel Hagerty
	Karl "Rat" Schilke and Electric Lightwave, Inc.
	Perl5 Porters
	Alex Burger

       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 net-snmp-users@lists.sourceforge.net

	    Copyright (c) 1995-2000 G. S. Marzot. All rights reserved.
	    This program is free software; you can redistribute it and/or
	    modify it under the same terms as Perl itself.

	    Copyright (c) 2001-2002 Networks Associates Technology, Inc.  All
	    Rights Reserved.  This program is free software; you can
	    redistribute it and/or modify it under the same terms as Perl

       Hey! The above document had some coding errors, which are explained below:

       Around line 1722:
	   '=item' outside of any '=over'

       Around line 1728:
	   You forgot a '=back' before '=head2'

perl v5.16.3				    2012-10-09					  SNMP(3)
Unix & Linux Commands & Man Pages : ©2000 - 2018 Unix and Linux Forums

All times are GMT -4. The time now is 02:22 AM.

Unix & Linux Forums Content Copyright©1993-2018. All Rights Reserved.
Show Password

Not a Forum Member?
Forgot Password?