开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
SNMP.pm
资源名称：net-snmp-5.2.2.rar　[点击查看]
上传用户：wxp200602
上传日期：2007-10-30
资源大小：4028k
文件大小：68k
源码类别：

SNMP编程

开发平台：

Unix_Linux

SNMP.pm：源码内容
  1. # SNMP.pm -- Perl 5 interface to the net-snmp toolkit
  2. #
  3. # written by G. S. Marzot (gmarzot@nortelnetworks.com)
  4. #
  5. #     Copyright (c) 1995-2000 G. S. Marzot. All rights reserved.
  6. #     This program is free software; you can redistribute it and/or
  7. #     modify it under the same terms as Perl itself.
  9. package SNMP;
  10. $VERSION = '5.2.2';   # current release version number
  12. require Exporter;
  13. require DynaLoader;
  14. require AutoLoader;
  16. use NetSNMP::default_store (':all');
  18. @SNMP::ISA = qw(Exporter AutoLoader DynaLoader);
  19. # Items to export into callers namespace by default. Note: do not export
  20. # names by default without a very good reason. Use EXPORT_OK instead.
  21. # Do not simply export all your public functions/methods/constants.
  22. @SNMP::EXPORT = qw(
  23. RECEIVED_MESSAGE
  24. SNMPERR_BAD_ADDRESS
  25. SNMPERR_BAD_LOCPORT
  26. SNMPERR_BAD_SESSION
  27. SNMPERR_GENERR
  28. SNMPERR_TOO_LONG
  29. SNMP_DEFAULT_ADDRESS
  30. SNMP_DEFAULT_COMMUNITY_LEN
  31. SNMP_DEFAULT_ENTERPRISE_LENGTH
  32. SNMP_DEFAULT_ERRINDEX
  33. SNMP_DEFAULT_ERRSTAT
  34. SNMP_DEFAULT_PEERNAME
  35. SNMP_DEFAULT_REMPORT
  36. SNMP_DEFAULT_REQID
  37. SNMP_DEFAULT_RETRIES
  38. SNMP_DEFAULT_TIME
  39. SNMP_DEFAULT_TIMEOUT
  40. SNMP_DEFAULT_VERSION
  41. TIMED_OUT
  42. snmp_get
  43.         snmp_getnext
  44.         snmp_set
  45.         snmp_trap
  46. );
  48. sub AUTOLOAD {
  49.     # This AUTOLOAD is used to 'autoload' constants from the constant()
  50.     # XS function.  If a constant is not found then control is passed
  51.     # to the AUTOLOAD in AutoLoader.
  52.     my($val,$pack,$file,$line);
  53.     local($constname);
  54.     ($constname = $AUTOLOAD) =~ s/.*:://;
  55.     # croak "&$module::constant not defined" if $constname eq 'constant';
  56.     $val = constant($constname, @_ ? $_[0] : 0);
  57.     if ($! != 0) {
  58. if ($! =~ /Invalid/) {
  59.     $AutoLoader::AUTOLOAD = $AUTOLOAD;
  60.     goto &AutoLoader::AUTOLOAD;
  61. }
  62. else {
  63.     ($pack,$file,$line) = caller;
  64.     die "Your vendor has not defined SNMP macro $constname, used at $file line $line.
  65. ";
  66. }
  67.     }
  68.     eval "sub $AUTOLOAD { $val }";
  69.     goto &$AUTOLOAD;
  70. }
  72. bootstrap SNMP;
  74. # Preloaded methods go here.
  76. # Package variables
  77. tie $SNMP::debugging, SNMP::DEBUGGING;
  78. tie $SNMP::debug_internals, SNMP::DEBUG_INTERNALS;
  79. tie $SNMP::dump_packet, SNMP::DUMP_PACKET;
  80. tie %SNMP::MIB, SNMP::MIB;
  81. tie $SNMP::save_descriptions, SNMP::MIB::SAVE_DESCR;
  82. tie $SNMP::replace_newer, SNMP::MIB::REPLACE_NEWER;
  83. tie $SNMP::mib_options, SNMP::MIB::MIB_OPTIONS;
  85. %SNMP::V3_SEC_LEVEL_MAP = (noAuthNoPriv => 1, authNoPriv => 2, authPriv =>3);
  87. $auto_init_mib = 1; # enable automatic MIB loading at session creation time
  88. $use_long_names = 0; # non-zero to prefer longer mib textual identifiers rather
  89.                    # than just leaf indentifiers (see translateObj)
  90.                    # may also be set on a per session basis(see UseLongNames)
  91. $use_sprint_value = 0; # non-zero to enable formatting of response values
  92.                    # using the snmp libraries "snprint_value"
  93.                    # may also be set on a per session basis(see UseSprintValue)
  94.                    # note: returned values not suitable for 'set' operations
  95. $use_enums = 0; # non-zero to return integers as enums and allow sets
  96.                 # using enums where appropriate - integer data will
  97.                 # still be accepted for set operations
  98.                 # may also be set on a per session basis (see UseEnums)
  99. $use_numeric = 0; # non-zero to return object tags as numeric OID's instead
  100.                   # of converting to textual representations.  use_long_names,
  101.                   # if non-zero, returns the entire OID, otherwise, return just
  102.                   # the label portion.  use_long_names is also set if the
  103.   # use_numeric variable is set.
  104. %MIB = ();      # tied hash to access libraries internal mib tree structure
  105.                 # parsed in from mib files
  106. $verbose = 0;   # controls warning/info output of SNMP module,
  107.                 # 0 => no output, 1 => enables warning and info
  108.                 # output from SNMP module itself (is also controlled
  109.                 # by SNMP::debugging)
  110. $debugging = 0; # non-zero to globally enable libsnmp do_debugging output
  111.                 # set to >= 2 to enabling packet dumping (see below)
  112. $dump_packet = 0; # non-zero to globally enable libsnmp dump_packet output.
  113.                   # is also enabled when $debugging >= 2
  114. $save_descriptions = 0; #tied scalar to control saving descriptions during
  115.                # mib parsing - must be set prior to mib loading
  116. $best_guess = 0;  # determine whether or not to enable best-guess regular
  117.                   # expression object name translation.  1 = Regex (-Ib),
  118.   # 2 = random (-IR)
  119. $replace_newer = 0; # determine whether or not to tell the parser to replace
  120.                     # older MIB modules with newer ones when loading MIBs.
  121.                     # WARNING: This can cause an incorrect hierarchy.
  123. sub setMib {
  124. # loads mib from file name provided
  125. # setting second arg to true causes currently loaded mib to be replaced
  126. # otherwise mib file will be added to existing loaded mib database
  127. # NOTE: now deprecated in favor of addMibFiles and new module based funcs
  128.    my $file = shift;
  129.    my $force = shift || '0';
  130.    return 0 if $file and not (-r $file);
  131.    SNMP::_read_mib($file,$force);
  132. }
  134. sub initMib {
  135. # eqivalent to calling the snmp library init_mib if Mib is NULL
  136. # if Mib is already loaded this function does nothing
  137. # Pass a zero valued argument to get minimal mib tree initialzation
  138. # If non zero agrgument or no argument then full mib initialization
  140.   SNMP::init_snmp("perl");
  141.   return;
  144.   if (defined $_[0] and $_[0] == 0) {
  145.     SNMP::_init_mib_internals();
  146.   } else {
  147.     SNMP::_read_mib("");
  148.   }
  149. }
  151. sub addMibDirs {
  152. # adds directories to search path when a module is requested to be loaded
  153.   SNMP::init_snmp("perl");
  154.   foreach (@_) {
  155.     SNMP::_add_mib_dir($_) or return undef;
  156.   }
  157.   return 1;
  158. }
  160. sub addMibFiles {
  161. # adds mib definitions to currently loaded mib database from
  162. # file(s) supplied
  163.   SNMP::init_snmp("perl");
  164.   foreach (@_) {
  165.     SNMP::_read_mib($_) or return undef;
  166.   }
  167.   return 1;
  168. }
  170. sub loadModules {
  171. # adds mib module definitions to currently loaded mib database.
  172. # Modules will be searched from previously defined mib search dirs
  173. # Passing and arg of 'ALL' will cause all known modules to be loaded
  174.    SNMP::init_snmp("perl");
  175.    foreach (@_) {
  176.      SNMP::_read_module($_) or return undef;
  177.    }
  178.    return 1;
  179. }
  181. sub unloadModules {
  182. # causes modules to be unloaded from mib database
  183. # Passing and arg of 'ALL' will cause all known modules to be unloaded
  184.   warn("SNMP::unloadModules not implemented! (yet)");
  185. }
  187. sub translateObj {
  188. # Translate object identifier(tag or numeric) into alternate representation
  189. # (i.e., sysDescr => '.1.3.6.1.2.1.1.1' and '.1.3.6.1.2.1.1.1' => sysDescr)
  190. # when $SNMP::use_long_names or second arg is non-zero the translation will
  191. # return longer textual identifiers (e.g., system.sysDescr).  An optional 
  192. # third argument of non-zero will cause the module name to be prepended
  193. # to the text name (e.g. 'SNMPv2-MIB::sysDescr').  If no Mib is loaded 
  194. # when called and $SNMP::auto_init_mib is enabled then the Mib will be 
  195. # loaded. Will return 'undef' upon failure.
  196.    SNMP::init_snmp("perl");
  197.    my $obj = shift;
  198.    my $temp = shift;
  199.    my $include_module_name = shift || "0";
  200.    my $long_names = $temp || $SNMP::use_long_names;
  202.    return undef if not defined $obj;
  203.    my $res;
  204.    if ($obj =~ /^.?(d+.)*d+$/) {
  205.       $res = SNMP::_translate_obj($obj,1,$long_names,$SNMP::auto_init_mib,0,$include_module_name);
  206.    } elsif ($obj =~ /(.d+)*$/ && $SNMP::best_guess == 0) {
  207.       $res = SNMP::_translate_obj($`,0,$long_names,$SNMP::auto_init_mib,0,$include_module_name);
  208.       $res .= $& if defined $res and defined $&;
  209.    } elsif ($SNMP::best_guess) {
  210.       $res = SNMP::_translate_obj($obj,0,$long_names,$SNMP::auto_init_mib,$SNMP::best_guess,$include_module_name);
  211.    }
  213.    return($res);
  214. }
  216. sub getType {
  217. # return SNMP data type for given textual identifier
  218. # OBJECTID, OCTETSTR, INTEGER, NETADDR, IPADDR, COUNTER
  219. # GAUGE, TIMETICKS, OPAQUE, or undef
  220.   my $tag = shift;
  221.   SNMP::_get_type($tag, $SNMP::best_guess);
  222. }
  224. sub mapEnum {
  225. # return the corresponding integer value *or* tag for a given MIB attribute
  226. # and value. The function will sense which direction to perform the conversion
  227. # various arg formats are supported
  228. #    $val = SNMP::mapEnum($varbind); # note: will update $varbind
  229. #    $val = SNMP::mapEnum('ipForwarding', 'forwarding');
  230. #    $val = SNMP::mapEnum('ipForwarding', 1);
  231. #
  232.   my $var = shift;
  233.   my ($tag, $val, $update);
  234.   if (ref($var) =~ /ARRAY/ or ref($var) =~ /Varbind/) {
  235.       $tag = $var->[$SNMP::Varbind::tag_f];
  236.       $val = $var->[$SNMP::Varbind::val_f];
  237.       $update = 1;
  238.   } else {
  239.       $tag = $var;
  240.       $val = shift;
  241.   }
  242.   my $iflag = $val =~ /^d+$/;
  243.   my $res = SNMP::_map_enum($tag, $val, $iflag, $SNMP::best_guess);
  244.   if ($update and defined $res) { $var->[$SNMP::Varbind::val_f] = $res; }
  245.   return($res);
  246. }
  248. %session_params = (DestHost => 1,
  249.    Community => 1,
  250.    Version => 1,
  251.    Timeout => 1,
  252.    Retries => 1,
  253.    RemotePort => 1,
  254.                    LocalPort => 1);
  256. sub strip_session_params {
  257.     my @params;
  258.     my @args;
  259.     my $param;
  260.     while ($param = shift) {
  261. push(@params,$param, shift), next
  262.     if $session_params{$param};
  263. push(@args,$param);
  264.     }
  265.     @_ = @args;
  266.     @params;
  267. }
  270. sub snmp_get {
  271. # procedural form of 'get' method. sometimes quicker to code
  272. # but is less efficient since the Session is created and destroyed
  273. # with each call. Takes all the parameters of both SNMP::Session::new and
  274. # SNMP::Session::get (*NOTE*: this api does not support async callbacks)
  276.     my @sess_params = &strip_session_params;
  277.     my $sess = new SNMP::Session(@sess_params);
  279.     $sess->get(@_);
  280. }
  282. sub snmp_getnext {
  283. # procedural form of 'getnext' method. sometimes quicker to code
  284. # but is less efficient since the Session is created and destroyed
  285. # with each call. Takes all the parameters of both SNMP::Session::new and
  286. # SNMP::Session::getnext (*NOTE*: this api does not support async callbacks)
  288.     my @sess_params = &strip_session_params;
  289.     my $sess = new SNMP::Session(@sess_params);
  291.     $sess->getnext(@_);
  292. }
  294. sub snmp_set {
  295. # procedural form of 'set' method. sometimes quicker to code
  296. # but is less efficient since the Session is created and destroyed
  297. # with each call. Takes all the parameters of both SNMP::Session::new and
  298. # SNMP::Session::set (*NOTE*: this api does not support async callbacks)
  300.     my @sess_params = &strip_session_params;
  301.     my $sess = new SNMP::Session(@sess_params);
  303.     $sess->set(@_);
  304. }
  306. sub snmp_trap {
  307. # procedural form of 'trap' method. sometimes quicker to code
  308. # but is less efficient since the Session is created and destroyed
  309. # with each call. Takes all the parameters of both SNMP::TrapSession::new and
  310. # SNMP::TrapSession::trap
  312.     my @sess_params = &strip_session_params;
  313.     my $sess = new SNMP::TrapSession(@sess_params);
  315.     $sess->trap(@_);
  316. }
  318. sub MainLoop {
  319.     my $time = shift;
  320.     my $callback = shift;
  321.     my $time_sec = ($time ? int $time : 0);
  322.     my $time_usec = ($time ? int(($time-$time_sec)*1000000) : 0);
  323.     SNMP::_main_loop($time_sec,$time_usec,$callback);
  324. }
  326. sub finish {
  327.     SNMP::_mainloop_finish();
  328. }
  330. sub reply_cb {
  331.     # callback function for async snmp calls
  332.     # when triggered, will do a SNMP read on the
  333.     # given fd
  334.     my $fd = shift;
  335.   SNMP::_read_on_fd($fd);
  336. }
  338. sub select_info {
  339.     # retrieves SNMP used fd's and timeout info
  340.     # calculates timeout in fractional seconds
  341.     # ( easy to use with select statement )
  342.     my($block, $to_sec, $to_usec, @fd_set)=SNMP::_get_select_info();
  343.     my $time_sec_dec = ($block? 0 : $to_sec + $to_usec * 1e-6);
  344.     #print "fd's for snmp -> ", @fd_set, "n";
  345.     #print "block -> ", $block, "n";
  346.     #print "timeout_sec -> ", $to_sec, "n";
  347.     #print "timeout_usec -> ", $to_usec, "n";
  348.     #print "timeout dec -> ", $time_sec_dec, "n";
  349.     return ($time_sec_dec,@fd_set);
  350. }
  352. sub check_timeout {
  353.   # check to see if a snmp session
  354.   # timed out, and if so triggers
  355.   # the callback function
  356.   SNMP::_check_timeout();
  357.   # check to see when have to check again
  358.   my($block, $to_sec, $to_usec, @fd_set)=SNMP::_get_select_info();
  359.   my $time_sec_dec = ($block? 0 : $to_sec + $to_usec * 1e-6);
  360.   #print "fd's for snmp -> ", @fd_set, "n";
  361.   #print "block -> ", $block, "n";
  362.   #print "timeout_sec -> ", $to_sec, "n";
  363.   #print "timeout_usec -> ", $to_usec, "n";
  364.   #print "timeout dec -> ", $time_sec_dec, "n";
  365.   return ($time_sec_dec);
  366. }
  368. sub _tie {
  369. # this is a little implementation hack so ActiveState can access pp_tie
  370. # thru perl code. All other environments allow the calling of pp_tie from
  371. # XS code but AS was not exporting it when PERL_OBJECT was used.
  372. #
  373. # short term solution was call this perl func which calls 'tie'
  374. #
  375. # longterm fix is to supply a patch which allows AS to export pp_tie in
  376. # such a way that it can be called from XS code. gsarathy says:
  377. # a patch to util.c is needed to provide access to PL_paddr
  378. # so it is possible to call PL_paddr[OP_TIE] as the compiler does
  379.     tie($_[0],$_[1],$_[2],$_[3]);
  380. }
  382. sub split_vars {
  383.     # This sub holds the regex that is used throughout this module  
  384.     #  to parse the base part of an OID from the IID.
  385.     #  eg: portName.9.30 -> ['portName','9.30'] 
  386.     my $vars = shift;
  388.     # The regex was changed to this simple form by patch 722075 for some reason.
  389.     # Testing shows now (2/05) that it is not needed, and that the long expression 
  390.     # works fine.  AB
  391.     # my ($tag, $iid) = ($vars =~ /^(.*?).?(d+)+$/);
  392.     
  393.     # These following two are the same.  Broken down for easier maintenance
  394.     # my ($tag, $iid) = ($vars =~ /^((?:.d+)+|(?:w+(?:-*w+)+)).?(.*)$/);
  395.     my ($tag, $iid) =
  396.         ($vars =~ /^(               # Capture $1
  397.                     # 1. either this 5.5.5.5
  398.                      (?:.d+)+     # for grouping, won't increment $1
  399.                     |
  400.                     # 2. or asdf-asdf-asdf-asdf
  401.                      (?:            # grouping again
  402.                         w+         # needs some letters followed by
  403.                         (?:-*w+)+ #  zero or more dashes, one or more letters
  404.                      )
  405.                     )
  406.                     .?             # optionally match a dot
  407.                     (.*)            # whatever is left in the string is our iid ($2)
  408.                    $/x
  409.     );
  410.     return [$tag,$iid];
  411. }
  413. package SNMP::Session;
  415. sub new {
  416.    my $type = shift;
  417.    my $this = {};
  418.    my ($name, $aliases, $host_type, $len, $thisaddr);
  420.    SNMP::init_snmp("perl");
  422.    %$this = @_;
  424.    $this->{ErrorStr} = ''; # if methods return undef check for expln.
  425.    $this->{ErrorNum} = 0;  # contains SNMP error return
  427.    $this->{Version} ||= 
  428.      NetSNMP::default_store::netsnmp_ds_get_int(NetSNMP::default_store::NETSNMP_DS_LIBRARY_ID, 
  429.       NetSNMP::default_store::NETSNMP_DS_LIB_SNMPVERSION) ||
  430. SNMP::SNMP_DEFAULT_VERSION();
  432.    if ($this->{Version} eq 128) {
  433.        # special handling of the bogus v1 definition.
  434.        $this->{Version} = 1;
  435.    }
  437.    # allow override of local SNMP port
  438.    $this->{LocalPort} ||= 0;
  440.    # destination host defaults to localhost
  441.    $this->{DestHost} ||= 'localhost';
  443.    # community defaults to public
  444.    $this->{Community} ||= NetSNMP::default_store::netsnmp_ds_get_string(NetSNMP::default_store::NETSNMP_DS_LIBRARY_ID(), 
  445.         NetSNMP::default_store::NETSNMP_DS_LIB_COMMUNITY()) || 'public';
  447.    # number of retries before giving up, defaults to SNMP_DEFAULT_RETRIES
  448.    $this->{Retries} = SNMP::SNMP_DEFAULT_RETRIES() unless defined($this->{Retries});
  450.    # timeout before retry, defaults to SNMP_DEFAULT_TIMEOUT
  451.    $this->{Timeout} = SNMP::SNMP_DEFAULT_TIMEOUT() unless defined($this->{Timeout});
  452.    # flag to enable fixing pdu and retrying with a NoSuch error
  453.    $this->{RetryNoSuch} ||= 0;
  455.    # backwards compatibility.  Make host = host:port
  456.    if ($this->{RemotePort} && $this->{DestHost} !~ /:/) {
  457.        $this->{DestHost} = $this->{DestHost} . ":" . $this->{RemotePort};
  458.    }
  460.    if ($this->{Version} eq '1' or $this->{Version} eq '2'
  461.        or $this->{Version} eq '2c') {
  462.        $this->{SessPtr} = SNMP::_new_session($this->{Version},
  463.      $this->{Community},
  464.      $this->{DestHost},
  465.      $this->{LocalPort},
  466.      $this->{Retries},
  467.      $this->{Timeout},
  468.      );
  469.    } elsif ($this->{Version} eq '3' ) {
  470.        $this->{SecName} ||= 
  471.    NetSNMP::default_store::netsnmp_ds_get_string(NetSNMP::default_store::NETSNMP_DS_LIBRARY_ID(), 
  472.          NetSNMP::default_store::NETSNMP_DS_LIB_SECNAME()) || 
  473.    'initial';
  474.        if (!$this->{SecLevel}) {
  475.    $this->{SecLevel} = 
  476.        NetSNMP::default_store::netsnmp_ds_get_int(NetSNMP::default_store::NETSNMP_DS_LIBRARY_ID(), 
  477.   NetSNMP::default_store::NETSNMP_DS_LIB_SECLEVEL()) || 
  478.       $SNMP::V3_SEC_LEVEL_MAP{'noAuthNoPriv'};
  479.        } elsif ($this->{SecLevel} !~ /^d+$/) {
  480.    $this->{SecLevel} = $SNMP::V3_SEC_LEVEL_MAP{$this->{SecLevel}};
  481.        }
  482.        $this->{SecEngineId} ||= '';
  483.        $this->{ContextEngineId} ||= $this->{SecEngineId};
  484.        $this->{Context} ||= 
  485.    NetSNMP::default_store::netsnmp_ds_get_string(NetSNMP::default_store::NETSNMP_DS_LIBRARY_ID(), 
  486.          NetSNMP::default_store::NETSNMP_DS_LIB_CONTEXT()) || '';
  487.        $this->{AuthProto} ||= 'DEFAULT'; # defaults to the library's default
  488.        $this->{AuthPass} ||=
  489.        NetSNMP::default_store::netsnmp_ds_get_string(NetSNMP::default_store::NETSNMP_DS_LIBRARY_ID(), 
  490.      NetSNMP::default_store::NETSNMP_DS_LIB_AUTHPASSPHRASE()) ||
  491.        NetSNMP::default_store::netsnmp_ds_get_string(NetSNMP::default_store::NETSNMP_DS_LIBRARY_ID(), 
  492.      NetSNMP::default_store::NETSNMP_DS_LIB_PASSPHRASE()) || '';
  494.        $this->{AuthMasterKey} ||= '';
  495.        $this->{PrivMasterKey} ||= '';
  496.        $this->{AuthLocalizedKey} ||= '';
  497.        $this->{PrivLocalizedKey} ||= '';
  499.        $this->{PrivProto} ||= 'DEFAULT';  # defaults to hte library's default
  500.        $this->{PrivPass} ||=
  501.        NetSNMP::default_store::netsnmp_ds_get_string(NetSNMP::default_store::NETSNMP_DS_LIBRARY_ID(), 
  502.      NetSNMP::default_store::NETSNMP_DS_LIB_PRIVPASSPHRASE()) ||
  503.        NetSNMP::default_store::netsnmp_ds_get_string(NetSNMP::default_store::NETSNMP_DS_LIBRARY_ID(), 
  504.      NetSNMP::default_store::NETSNMP_DS_LIB_PASSPHRASE()) || '';
  505.        $this->{EngineBoots} = 0 if not defined $this->{EngineBoots};
  506.        $this->{EngineTime} = 0 if not defined $this->{EngineTime};
  508.        $this->{SessPtr} = SNMP::_new_v3_session($this->{Version},
  509. $this->{DestHost},
  510. $this->{Retries},
  511. $this->{Timeout},
  512. $this->{SecName},
  513. $this->{SecLevel},
  514. $this->{SecEngineId},
  515. $this->{ContextEngineId},
  516. $this->{Context},
  517. $this->{AuthProto},
  518. $this->{AuthPass},
  519. $this->{PrivProto},
  520. $this->{PrivPass},
  521. $this->{EngineBoots},
  522. $this->{EngineTime},
  523. $this->{AuthMasterKey},
  524. length($this->{AuthMasterKey}),
  525. $this->{PrivMasterKey},
  526. length($this->{PrivMasterKey}),
  527. $this->{AuthLocalizedKey},
  528. length($this->{AuthLocalizedKey}),
  529. $this->{PrivLocalizedKey},
  530. length($this->{PrivLocalizedKey}),
  531.        );
  532.    }
  533.    unless ($this->{SessPtr}) {
  534.        warn("unable to create session") if $SNMP::verbose;
  535.        return undef;
  536.    }
  538.    SNMP::initMib($SNMP::auto_init_mib); # ensures that *some* mib is loaded
  540.    $this->{UseLongNames} ||= $SNMP::use_long_names;
  541.    $this->{UseSprintValue} ||= $SNMP::use_sprint_value;
  542.    $this->{BestGuess} ||= $SNMP::best_guess;
  543.    $this->{UseEnums} ||= $SNMP::use_enums;
  544.    $this->{UseNumeric} ||= $SNMP::use_numeric;
  546.    # Force UseLongNames if UseNumeric is in use.
  547.    $this->{UseLongNames}++  if $this->{UseNumeric};
  549.    bless $this, $type;
  550. }
  552. sub update {
  553. # *Not Implemented*
  554. # designed to update the fields of session to allow retargetting to different
  555. # host, community name change, timeout, retry changes etc. Unfortunately not
  556. # working yet because some updates (the address in particular) need to be
  557. # done on the internal session pointer which cannot be fetched w/o touching
  558. # globals at this point which breaks win32. A patch to the ucd-snmp toolkit
  559. # is needed
  560.    my $this = shift;
  561.    my ($name, $aliases, $host_type, $len, $thisaddr);
  562.    my %new_fields = @_;
  564.    @$this{keys %new_fields} = values %new_fields;
  566.    $this->{UseLongNames} ||= $SNMP::use_long_names;
  567.    $this->{UseSprintValue} ||= $SNMP::use_sprint_value;
  568.    $this->{BestGuess} ||= $SNMP::best_guess;
  569.    $this->{UseEnums} ||= $SNMP::use_enums;
  570.    $this->{UseNumeric} ||= $SNMP::use_numeric;
  572.    # Force UseLongNames if UseNumeric is in use.
  573.    $this->{UseLongNames}++  if $this->{UseNumeric};
  575.    SNMP::_update_session($this->{Version},
  576.  $this->{Community},
  577.  $this->{DestHost},
  578.  $this->{RemotePort},
  579.  $this->{LocalPort},
  580.  $this->{Retries},
  581.  $this->{Timeout},
  582. );
  585. }
  587. sub set {
  588.    my $this = shift;
  589.    my $vars = shift;
  590.    my $varbind_list_ref;
  591.    my $res = 0;
  593.    if (ref($vars) =~ /SNMP::VarList/) {
  594.      $varbind_list_ref = $vars;
  595.    } elsif (ref($vars) =~ /SNMP::Varbind/) {
  596.      $varbind_list_ref = [$vars];
  597.    } elsif (ref($vars) =~ /ARRAY/) {
  598.      $varbind_list_ref = [$vars];
  599.      $varbind_list_ref = $vars if ref($$vars[0]) =~ /ARRAY/;
  600.    } else {
  601.      #$varbind_list_ref = [[$tag, $iid, $val]];
  602.      my $split_vars = SNMP::split_vars($vars);
  603.      my $val = shift;
  604.      push @$split_vars,$val;
  605.      $varbind_list_ref = [$split_vars];
  606.    }
  607.    my $cb = shift;
  609.    $res = SNMP::_set($this, $varbind_list_ref, $cb);
  610. }
  612. sub get {
  613.    my $this = shift;
  614.    my $vars = shift;
  615.    my ($varbind_list_ref, @res);
  617.    if (ref($vars) =~ /SNMP::VarList/) {
  618.      $varbind_list_ref = $vars;
  619.    } elsif (ref($vars) =~ /SNMP::Varbind/) {
  620.      $varbind_list_ref = [$vars];
  621.    } elsif (ref($vars) =~ /ARRAY/) {
  622.      $varbind_list_ref = [$vars];
  623.      $varbind_list_ref = $vars if ref($$vars[0]) =~ /ARRAY/;
  624.    } else {
  625.      $varbind_list_ref = [SNMP::split_vars($vars)];
  626.    }
  628.    my $cb = shift;
  630.    @res = SNMP::_get($this, $this->{RetryNoSuch}, $varbind_list_ref, $cb);
  632.    return(wantarray() ? @res : $res[0]);
  633. }
  636. $have_netsnmp_oid = eval { require NetSNMP::OID; };
  637. sub gettable {
  639.     #
  640.     # getTable
  641.     # --------
  642.     #
  643.     # Get OIDs starting at $table_oid, and continue down the tree
  644.     # until we get to an OID which does not start with $table_oid,
  645.     # i.e. we have reached the end of this table.
  646.     #
  648.     my ($this, $root_oid, $options) = @_;
  649.     my ($textnode, $stopconds, $varbinds, $vbl, $res, %result_hash, $repeat);
  651.     # translate the OID into numeric form if its not
  652.     if ($root_oid !~ /^[.0-9]+$/) {
  653. $textnode = $root_oid;
  654. $root_oid = SNMP::translateObj($root_oid);
  655.     } else {
  656. $textnode = SNMP::translateObj($root_oid);
  657.     }
  659.     # bail if we don't have a valid oid.
  660.     return if (!$root_oid);
  662.     # deficed if we're going to parse indexes
  663.     my $parse_indexes = (defined($options->{'noindexes'})) ? 
  664.       0 : $have_netsnmp_oid;
  666.     # get the list of columns we should look at.
  667.     my @columns;
  668.     if (!$options->{'columns'}) {
  669. if ($textnode) {
  670.     my %indexes;
  672.     if ($parse_indexes) {
  673. # get indexes
  674. my @indexes =
  675.   @{$SNMP::MIB{$textnode}{'children'}[0]{'indexes'}};
  676. # quick translate into a hash
  677. map { $indexes{$_} = 1; } @indexes;
  678.     }
  680.     # calculate the list of accessible columns that aren't indexes
  681.     my $children = $SNMP::MIB{$textnode}{'children'}[0]{'children'};
  682.     foreach my $c (@$children) {
  683. push @columns,
  684.   $root_oid . ".1." . $c->{'subID'}
  685.     if (!$indexes{$c->{'label'}});
  686.     }
  687.     if ($#columns == -1) {
  688. # some tables are only indexes, and we need to walk at
  689. # least one column.  We pick the last.
  690. push @columns, $root_oid . ".1." .
  691.   $children->[$#$children]{'subID'};
  692.     }
  693. }
  694.     } else {
  695. # XXX: requires specification in numeric OID...  ack.!
  696. @columns = @{$options->{'columns'}};
  697.     }
  699.     # create the initial walking info.
  700.     foreach my $c (@columns) {
  701. push @$varbinds, [$c];
  702. push @$stopconds, $c;
  703.     }
  704.     $vbl = $varbinds;
  706.     my $repeatcount;
  707.     if ($opts->{nogetbulk}) {
  708. $repeatcount = 1;
  709.     } elsif ($options->{'repeat'}) {
  710. $repeatcount = $options->{'repeat'};
  711.     } else {
  712. # experimentally determined maybe guess at a best repeat value
  713. # 1000 bytes max (safe), 30 bytes average for encoding of the
  714. # varbind (experimentally determined to be closer to
  715. # 26.  Again, being safe.  Then devide by the number of
  716. # varbinds.
  717. $repeatcount = int(1000 / 36 / ($#$varbinds + 1));
  718.     }
  720.     if ($this->{Version} > 1 && !$options->{'nogetbulk'}) {
  721. $res = $this->getbulk(0, $repeatcount, $vbl);
  722.     } else {
  723. $res = $this->getnext($vbl);
  724.     }
  726.     while ($#$vbl > -1 && !$this->{ErrorNum}) {
  727. if ($#$vbl + 1 != ($#$stopconds + 1) * $repeatcount) {
  728.     print STDERR "ack: gettable results not appropriaten";
  729.     my @k = keys(%result_hash);
  730.     last if ($#k > -1);  # bail with what we have
  731.     return;
  732. }
  734. $varbinds = [];
  735. my $newstopconds;
  737. my $lastsetstart = ($repeatcount-1) * ($#$stopconds+1);
  739. for (my $i = 0; $i <= $#$vbl; $i++) {
  740.     my $row_oid = SNMP::translateObj($vbl->[$i][0]);
  741.     my $row_text = $vbl->[$i][0];
  742.     my $row_index = $vbl->[$i][1];
  743.     my $row_value = $vbl->[$i][2];
  744.     my $row_type = $vbl->[$i][3];
  746.     if ($row_oid =~ /^$stopconds->[$i % ($#$stopconds+1)]/) {
  748. if ($row_type eq "OBJECTID") {
  750. # If the value returned is an OID, translate this
  751. # back in to a textual OID
  753.     $row_value = SNMP::translateObj($row_value);
  755. }
  757. # Place the results in a hash
  759. $result_hash{$row_index}{$row_text} = $row_value;
  761. # continue past this next time
  762. if ($i >= $lastsetstart) {
  763.     push @$newstopconds, $stopconds->[$i%($#$stopconds+1)];
  764.     push @$varbinds,[$vbl->[$i][0],$vbl->[$i][1]];
  765. }
  766.     }
  767. }
  768. if ($#$newstopconds == -1) {
  769.     last;
  770. }
  771. if ($#$varbinds == -1) {
  772.     print "gettable ack.  shouldn't get heren";
  773. }
  774. $vbl = $varbinds;
  775. $stopconds = $newstopconds;
  777. if ($this->{Version} > 1 && !$options->{'nogetbulk'}) {
  778.     $res = $this->getbulk(0, $repeatcount, $vbl);
  779. } else {
  780.     $res = $this->getnext($vbl);
  781. }
  782.     }
  784.     # calculate indexes
  785.     if ($parse_indexes) {
  786. my @indexes = @{$SNMP::MIB{$textnode}{'children'}[0]{'indexes'}};
  787. my $i;
  788. foreach my $trow (keys(%result_hash)) {
  789.     my $noid = new NetSNMP::OID($columns[0] . "." . $trow);
  790.     if (!$noid) {
  791. print STDERR "***** ERROR parsing $columns[0].$trow MIB OIDn";
  792. next;
  793.     }
  794.     my $nindexes = $noid->get_indexes();
  795.     if (!$nindexes || ref($nindexes) ne 'ARRAY' ||
  796. $#indexes != $#$nindexes) {
  797. print STDERR "***** ERROR parsing $columns[0].$trow MIB indexes: $noid => " . ref($nindexes) . " [should be an ARRAY], expended # indexes = $#indexesn";
  798. if (ref($nindexes) eq 'ARRAY') {
  799.     print STDERR "***** ERROR parsing $columns[0].$trow MIB indexes: " . ref($nindexes) . " $#indexes $#$nindexesn";
  800. }
  801. next;
  802.     }
  804.     for ($i = 0; $i <= $#indexes; $i++) {
  805. $result_hash{$trow}{$indexes[$i]} = $nindexes->[$i];
  806.     }
  807. }
  808.     }
  810.     return(%result_hash);
  811. }
  813. sub fget {
  814.    my $this = shift;
  815.    my $vars = shift;
  816.    my ($varbind_list_ref, @res);
  818.    if (ref($vars) =~ /SNMP::VarList/) {
  819.      $varbind_list_ref = $vars;
  820.    } elsif (ref($vars) =~ /SNMP::Varbind/) {
  821.      $varbind_list_ref = [$vars];
  822.    } elsif (ref($vars) =~ /ARRAY/) {
  823.      $varbind_list_ref = [$vars];
  824.      $varbind_list_ref = $vars if ref($$vars[0]) =~ /ARRAY/;
  825.    } else {
  826.      $varbind_list_ref = [SNMP::split_vars($vars)];
  827.    }
  829.    my $cb = shift;
  831.    SNMP::_get($this, $this->{RetryNoSuch}, $varbind_list_ref, $cb);
  833.    foreach $varbind (@$varbind_list_ref) {
  834.      $sub = $this->{VarFormats}{$varbind->[$SNMP::Varbind::tag_f]} ||
  835.  $this->{TypeFormats}{$varbind->[$SNMP::Varbind::type_f]};
  836.      &$sub($varbind) if defined $sub;
  837.      push(@res, $varbind->[$SNMP::Varbind::val_f]);
  838.    }
  840.    return(wantarray() ? @res : $res[0]);
  841. }
  843. sub getnext {
  844.    my $this = shift;
  845.    my $vars = shift;
  846.    my ($varbind_list_ref, @res);
  848.    if (ref($vars) =~ /SNMP::VarList/) {
  849.      $varbind_list_ref = $vars;
  850.    } elsif (ref($vars) =~ /SNMP::Varbind/) {
  851.      $varbind_list_ref = [$vars];
  852.    } elsif (ref($vars) =~ /ARRAY/) {
  853.      $varbind_list_ref = [$vars];
  854.      $varbind_list_ref = $vars if ref($$vars[0]) =~ /ARRAY/;
  855.    } else {
  856.      $varbind_list_ref = [SNMP::split_vars($vars)];
  857.    }
  859.    my $cb = shift;
  861.    @res = SNMP::_getnext($this, $varbind_list_ref, $cb);
  863.    return(wantarray() ? @res : $res[0]);
  864. }
  866. sub fgetnext {
  867.    my $this = shift;
  868.    my $vars = shift;
  869.    my ($varbind_list_ref, @res);
  871.    if (ref($vars) =~ /SNMP::VarList/) {
  872.      $varbind_list_ref = $vars;
  873.    } elsif (ref($vars) =~ /SNMP::Varbind/) {
  874.      $varbind_list_ref = [$vars];
  875.    } elsif (ref($vars) =~ /ARRAY/) {
  876.      $varbind_list_ref = [$vars];
  877.      $varbind_list_ref = $vars if ref($$vars[0]) =~ /ARRAY/;
  878.    } else {
  879.      $varbind_list_ref = [SNMP::split_vars($vars)];
  880.    }
  882.    my $cb = shift;
  884.    SNMP::_getnext($this, $varbind_list_ref, $cb);
  886.    foreach $varbind (@$varbind_list_ref) {
  887.      $sub = $this->{VarFormats}{$varbind->[$SNMP::Varbind::tag_f]} ||
  888.  $this->{TypeFormats}{$varbind->[$SNMP::Varbind::type_f]};
  889.      &$sub($varbind) if defined $sub;
  890.      push(@res, $varbind->[$SNMP::Varbind::val_f]);
  891.    }
  893.    return(wantarray() ? @res : $res[0]);
  894. }
  896. sub getbulk {
  897.    my $this = shift;
  898.    my $nonrepeaters = shift;
  899.    my $maxrepetitions = shift;
  900.    my $vars = shift;
  901.    my ($varbind_list_ref, @res);
  903.    if (ref($vars) =~ /SNMP::VarList/) {
  904.      $varbind_list_ref = $vars;
  905.    } elsif (ref($vars) =~ /SNMP::Varbind/) {
  906.      $varbind_list_ref = [$vars];
  907.    } elsif (ref($vars) =~ /ARRAY/) {
  908.      $varbind_list_ref = [$vars];
  909.      $varbind_list_ref = $vars if ref($$vars[0]) =~ /ARRAY/;
  910.    } else {
  911.      $varbind_list_ref = [SNMP::split_vars($vars)];
  912.    }
  914.    my $cb = shift;
  916.    @res = SNMP::_getbulk($this, $nonrepeaters, $maxrepetitions, $varbind_list_ref, $cb);
  918.    return(wantarray() ? @res : $res[0]);
  919. }
  921. sub bulkwalk {
  922.    my $this = shift;
  923.    my $nonrepeaters = shift;
  924.    my $maxrepetitions = shift;
  925.    my $vars = shift;
  926.    my ($varbind_list_ref, @res);
  928.    if (ref($vars) =~ /SNMP::VarList/) {
  929.       $varbind_list_ref = $vars;
  930.    } elsif (ref($vars) =~ /SNMP::Varbind/) {
  931.       $varbind_list_ref = [$vars];
  932.    } elsif (ref($vars) =~ /ARRAY/) {
  933.       $varbind_list_ref = [$vars];
  934.       $varbind_list_ref = $vars if ref($$vars[0]) =~ /ARRAY/;
  935.    } else {
  936.       # my ($tag, $iid) = ($vars =~ /^((?:.d+)+|w+).?(.*)$/);
  937.       my ($tag, $iid) = ($vars =~ /^(.*?).?(d+)+$/);
  938.       $varbind_list_ref = [[$tag, $iid]];
  939.    }
  941.    if (scalar @$varbind_list_ref == 0) {
  942.       $this->{ErrorNum} = SNMP::constant("SNMPERR_GENERR", 0);
  943.       $this->{ErrorStr} = "cannot bulkwalk() empty variable list";
  944.       return undef;
  945.    }
  946.    if (scalar @$varbind_list_ref < $nonrepeaters) {
  947.       $this->{ErrorNum} = SNMP::constant("SNMPERR_GENERR", 0);
  948.       $this->{ErrorStr} = "bulkwalk() needs at least $nonrepeaters varbinds";
  949.       return undef;
  950.    }
  952.    my $cb = shift;
  953.    @res = SNMP::_bulkwalk($this, $nonrepeaters, $maxrepetitions,
  954. $varbind_list_ref, $cb);
  956.    # Return, in list context, a copy of the array of arrays of Varbind refs.
  957.    # In scalar context, return either a reference to the array of arrays of
  958.    # Varbind refs, or the request ID for an asynchronous bulkwalk.  This is
  959.    # a compromise between the getbulk()-ish return, and the more useful array
  960.    # of arrays of Varbinds return from the synchronous bulkwalk().
  961.    #
  962.    return @res if (wantarray());
  963.    return defined($cb) ? $res[0] : @res;
  964. }
  966. %trap_type = (coldStart => 0, warmStart => 1, linkDown => 2, linkUp => 3,
  967.       authFailure => 4, egpNeighborLoss => 5, specific => 6 );
  968. sub trap {
  969. # (v1) enterprise, agent, generic, specific, uptime, <vars>
  970. # $sess->trap(enterprise=>'.1.3.6.1.4.1.2021', # or 'ucdavis' [default]
  971. #             agent => '127.0.0.1', # or 'localhost',[default 1st intf on host]
  972. #             generic => specific,  # can be omitted if 'specific' supplied
  973. #             specific => 5,        # can be omitted if 'generic' supplied
  974. #             uptime => 1234,       # default to localhost uptime (0 on win32)
  975. #             [[ifIndex, 1, 1],[sysLocation, 0, "here"]]); # optional vars
  976. #                                                          # always last
  977. # (v2) oid, uptime, <vars>
  978. # $sess->trap(uptime => 1234,
  979. #             oid => 'snmpRisingAlarm',
  980. #             [[ifIndex, 1, 1],[sysLocation, 0, "here"]]); # optional vars
  981. #                                                          # always last
  982. #                                                          # always last
  985.    my $this = shift;
  986.    my $vars = pop if ref($_[$#_]); # last arg may be varbind or varlist
  987.    my %param = @_;
  988.    my ($varbind_list_ref, @res);
  990.    if (ref($vars) =~ /SNMP::VarList/) {
  991.      $varbind_list_ref = $vars;
  992.    } elsif (ref($vars) =~ /SNMP::Varbind/) {
  993.      $varbind_list_ref = [$vars];
  994.    } elsif (ref($vars) =~ /ARRAY/) {
  995.      $varbind_list_ref = [$vars];
  996.      $varbind_list_ref = $vars if ref($$vars[0]) =~ /ARRAY/;
  997.    }
  999.    if ($this->{Version} eq '1') {
  1000.        my $enterprise = $param{enterprise} || 'ucdavis';
  1001.        $enterprise = SNMP::translateObj($enterprise)
  1002.    unless $enterprise =~ /^[.d]+$/;
  1003.        my $agent = $param{agent} || '';
  1004.        my $generic = $param{generic} || 'specific';
  1005.        $generic = $trap_type{$generic} || $generic;
  1006.        my $uptime = $param{uptime} || SNMP::_sys_uptime();
  1007.        my $specific = $param{specific} || 0;
  1008.        @res = SNMP::_trapV1($this, $enterprise, $agent, $generic, $specific,
  1009.   $uptime, $varbind_list_ref);
  1010.    } elsif  (($this->{Version} eq '2')|| ($this->{Version} eq '2c')) {
  1011.        my $trap_oid = $param{oid} || $param{trapoid} || '.0.0';
  1012.        my $uptime = $param{uptime} || SNMP::_sys_uptime();
  1013.        @res = SNMP::_trapV2($this, $uptime, $trap_oid, $varbind_list_ref);
  1014.    }
  1016.    return(wantarray() ? @res : $res[0]);
  1017. }
  1019. sub inform {
  1020. # (v3) oid, uptime, <vars>
  1021. # $sess->inform(uptime => 1234,
  1022. #             oid => 'coldStart',
  1023. #             [[ifIndex, 1, 1],[sysLocation, 0, "here"]]); # optional vars
  1024. #                                                          # then callback
  1025.                                                            # always last
  1028.    my $this = shift;
  1029.    my $vars;
  1030.    my $cb;
  1031.    $cb = pop if ref($_[$#_]) eq 'CODE'; # last arg may be code
  1032.    $vars = pop if ref($_[$#_]); # varbind or varlist
  1033.    my %param = @_;
  1034.    my ($varbind_list_ref, @res);
  1036.    if (ref($vars) =~ /SNMP::VarList/) {
  1037.      $varbind_list_ref = $vars;
  1038.    } elsif (ref($vars) =~ /SNMP::Varbind/) {
  1039.      $varbind_list_ref = [$vars];
  1040.    } elsif (ref($vars) =~ /ARRAY/) {
  1041.      $varbind_list_ref = [$vars];
  1042.      $varbind_list_ref = $vars if ref($$vars[0]) =~ /ARRAY/;
  1043.    }
  1045.    my $trap_oid = $param{oid} || $param{trapoid};
  1046.    my $uptime = $param{uptime} || SNMP::_sys_uptime();
  1048.    if($this->{Version} eq '3') {
  1049.      @res = SNMP::_inform($this, $uptime, $trap_oid, $varbind_list_ref, $cb);
  1050.    } else {
  1051.      warn("error:inform: This version doesn't support the commandn");
  1052.    }
  1054.    return(wantarray() ? @res : $res[0]);
  1055. }
  1057. package SNMP::TrapSession;
  1058. @ISA = ('SNMP::Session');
  1060. sub new {
  1061.    my $type = shift;
  1063.    # allow override of remote SNMP trap port
  1064.    unless (grep(/RemotePort/, @_)) {
  1065.        push(@_, 'RemotePort', 162); # push on new default for trap session
  1066.    }
  1068.    SNMP::Session::new($type, @_);
  1069. }
  1071. package SNMP::Varbind;
  1073. $tag_f = 0;
  1074. $iid_f = 1;
  1075. $val_f = 2;
  1076. $type_f = 3;
  1077. $time_f = 4;
  1079. sub new {
  1080.    my $type = shift;
  1081.    my $this = shift;
  1082.    $this ||= [];
  1083.    bless $this;
  1084. }
  1086. sub tag {
  1087.   $_[0]->[$tag_f];
  1088. }
  1090. sub iid {
  1091.   $_[0]->[$iid_f];
  1092. }
  1094. sub val {
  1095.   $_[0]->[$val_f];
  1096. }
  1098. sub type {
  1099.   $_[0]->[$type_f];
  1100. }
  1102. sub name {
  1103.    if (defined($_[0]->[$iid_f]) && ($_[0]->[$iid_f] =~ m/^[0-9]+$/)) {
  1104.       return $_[0]->[$tag_f] . "." . $_[0]->[$iid_f];
  1105.    }
  1107.    return $_[0]->[$tag_f];
  1108. }
  1110. sub fmt {
  1111.     my $self = shift;
  1112.     return $self->name . " = "" . $self->val . "" (" . $self->type . ")";
  1113. }
  1116. #sub DESTROY {
  1117. #    print "SNMP::Varbind::DESTROY($_[0])n";
  1118. #}
  1120. package SNMP::VarList;
  1122. sub new {
  1123.    my $type = shift;
  1124.    my $this = [];
  1125.    my $varb;
  1126.    foreach $varb (@_) {
  1127.      $varb = new SNMP::Varbind($varb) unless ref($varb) =~ /SNMP::Varbind/;
  1128.      push(@{$this}, $varb);
  1129.    }
  1131.    bless $this;
  1132. }
  1134. #sub DESTROY {
  1135. #    print "SNMP::VarList::DESTROY($_[0])n";
  1136. #}
  1138. package SNMP::DEBUGGING;
  1139. # controls info/debugging output from SNMP module and libsnmp
  1140. # $SNMP::debugging == 1    =>   enables general info and warning output
  1141. #                                (eqiv. to setting $SNMP::verbose)
  1142. # $SNMP::debugging == 2    =>   enables do_debugging from libsnmp as well
  1143. # $SNMP::debugging == 3    =>   enables packet_dump from libsnmp as well
  1144. sub TIESCALAR { my $class = shift; my $val; bless $val, $class; }
  1146. sub FETCH { ${$_[0]}; }
  1148. sub STORE {
  1149.     $SNMP::verbose = $_[1];
  1150.     SNMP::_set_debugging($_[1]>1);
  1151.     $SNMP::dump_packet = ($_[1]>2);
  1152.     ${$_[0]} = $_[1];
  1153. }
  1155. sub DELETE {
  1156.     $SNMP::verbose = 0;
  1157.     SNMP::_set_debugging(0);
  1158.     $SNMP::dump_packet = 0;
  1159.     ${$_[0]} = undef;
  1160. }
  1162. package SNMP::DEBUG_INTERNALS; # Controls SNMP.xs debugging.
  1163. sub TIESCALAR { my $class = shift; my $val; bless $val, $class; }
  1165. sub FETCH { ${$_[0]}; }
  1167. sub STORE {
  1168.     SNMP::_debug_internals($_[1]);
  1169.     ${$_[0]} = $_[1];
  1170. }
  1172. sub DELETE {
  1173.     SNMP::_debug_internals(0);
  1174.     ${$_[0]} = undef;
  1175. }
  1177. package SNMP::DUMP_PACKET;
  1178. # controls packet dump output from libsnmp
  1180. sub TIESCALAR { my $class = shift; my $val; bless $val, $class; }
  1182. sub FETCH { ${$_[0]}; }
  1184. sub STORE { SNMP::_dump_packet($_[1]); ${$_[0]} = $_[1]; }
  1186. sub DELETE { SNMP::_dump_packet(0); ${$_[0]} = 0; }
  1188. package SNMP::MIB;
  1190. sub TIEHASH {
  1191.     bless {};
  1192. }
  1194. sub FETCH {
  1195.     my $this = shift;
  1196.     my $key = shift;
  1198.     if (!defined $this->{$key}) {
  1199. tie(%{$this->{$key}}, SNMP::MIB::NODE, $key) or return undef;
  1200.     }
  1201.     $this->{$key};
  1202. }
  1204. sub STORE {
  1205.     warn "STORE(@_) : write access to the MIB not implementedn";
  1206. }
  1208. sub DELETE {
  1209.     delete $_[0]->{$_[1]}; # just delete cache entry
  1210. }
  1212. sub FIRSTKEY { return '.1'; } # this should actually start at .0 but
  1213.                               # because nodes are not stored in lexico
  1214.                               # order in ucd-snmp node tree walk will
  1215.                               # miss most of the tree
  1216. sub NEXTKEY { # this could be sped up by using an XS __get_next_oid maybe
  1217.    my $node = $_[0]->FETCH($_[1])->{nextNode};
  1218.    $node->{objectID};
  1219. }
  1220. sub EXISTS { exists $_[0]->{$_[1]} || $_[0]->FETCH($_[1]); }
  1221. sub CLEAR { undef %{$_[0]}; } # clear the cache
  1223. package SNMP::MIB::NODE;
  1224. my %node_elements =
  1225.     (
  1226.      objectID => 0, # dotted decimal fully qualified OID
  1227.      label => 0,    # leaf textual identifier (e.g., 'sysDescr')
  1228.      subID => 0,    # leaf numeric OID component of objectID (e.g., '1')
  1229.      moduleID => 0, # textual identifier for module (e.g., 'RFC1213-MIB')
  1230.      parent => 0,   # parent node
  1231.      children => 0, # array reference of children nodes
  1232.      indexes => 0,  # returns array of column labels
  1233.      varbinds => 0, # returns array of trap/notification varbinds
  1234.      nextNode => 0, # next lexico node (BUG! does not return in lexico order)
  1235.      type => 0,     # returns simple type (see getType for values)
  1236.      access => 0,   # returns ACCESS (ReadOnly, ReadWrite, WriteOnly,
  1237.                     # NoAccess, Notify, Create)
  1238.      status => 0,   # returns STATUS (Mandatory, Optional, Obsolete,
  1239.                     # Deprecated)
  1240.      syntax => 0,   # returns 'textualConvention' if defined else 'type'
  1241.      textualConvention => 0, # returns TEXTUAL-CONVENTION
  1242.      units => 0,    # returns UNITS
  1243.      hint => 0,     # returns HINT
  1244.      enums => 0,    # returns hash ref {tag => num, ...}
  1245.      ranges => 0,   # returns array ref of hash ref [{low => num, high => num}]
  1246.      defaultValue => 0, # returns default value
  1247.      description => 0, # returns DESCRIPTION ($SNMP::save_descriptions must
  1248.                     # be set prior to MIB initialization/parsing
  1249.      augments => 0, # textual identifier of augmented object
  1250.     );
  1252. # sub TIEHASH - implemented in SNMP.xs
  1254. # sub FETCH - implemented in SNMP.xs
  1256. sub STORE {
  1257.     warn "STORE(@_): write access to MIB node not implementedn";
  1258. }
  1260. sub DELETE {
  1261.     warn "DELETE(@_): write access to MIB node not implementedn";
  1262. }
  1264. sub FIRSTKEY { my $k = keys %node_elements; (each(%node_elements))[0]; }
  1265. sub NEXTKEY { (each(%node_elements))[0]; }
  1266. sub EXISTS { exists($node_elements{$_[1]}); }
  1267. sub CLEAR {
  1268.     warn "CLEAR(@_): write access to MIB node not implementedn";
  1269. }
  1271. #sub DESTROY {
  1272. #    warn "DESTROY(@_): write access to MIB node not implementedn";
  1273. #    # print "SNMP::MIB::NODE::DESTROY : $_[0]->{label} ($_[0])n";
  1274. #}
  1275. package SNMP::MIB::SAVE_DESCR;
  1277. sub TIESCALAR { my $class = shift; my $val; bless $val, $class; }
  1279. sub FETCH { ${$_[0]}; }
  1281. sub STORE { SNMP::_set_save_descriptions($_[1]); ${$_[0]} = $_[1]; }
  1283. sub DELETE { SNMP::_set_save_descriptions(0); ${$_[0]} = 0; }
  1285. package SNMP::MIB::REPLACE_NEWER;               # Controls MIB parsing
  1287. sub TIESCALAR { my $class = shift; my $val; bless $val, $class; }
  1289. sub FETCH { ${$_[0]}; }
  1291. sub STORE {
  1292.     SNMP::_set_replace_newer($_[1]);
  1293.     ${$_[0]} = $_[1];
  1294. }
  1296. sub DELETE {
  1297.     SNMP::_set_replace_newer(0);
  1298.     ${$_[0]} = 0;
  1299. }
  1301. package SNMP::MIB::MIB_OPTIONS;
  1303. sub TIESCALAR { my $class = shift; my $val; bless $val, $class; }
  1305. sub FETCH { ${$_[0]}; }
  1307. sub STORE { SNMP::_mib_toggle_options($_[1]); ${$_[0]} = $_[1]; }
  1309. sub DELETE { SNMP::_mib_toggle_options(0); ${$_[0]} = ''; }
  1311. package SNMP;
  1312. END{SNMP::_sock_cleanup() if defined &SNMP::_sock_cleanup;}
  1313. # Autoload methods go after __END__, and are processed by the autosplit prog.
  1315. 1;
  1316. __END__
  1318. =head1 NAME
  1320. SNMP - The Perl5 'SNMP' Extension Module for the Net-SNMP SNMP package.
  1322. =head1 SYNOPSIS
  1324.  use SNMP;
  1325.  ...
  1326.  $sess = new SNMP::Session(DestHost => localhost, Community => public);
  1327.  $val = $sess->get('sysDescr.0');
  1328.  ...
  1329.  $vars = new SNMP::VarList([sysDescr,0], [sysContact,0], [sysLocation,0]);
  1330.  @vals = $sess->get($vars);
  1331.  ...
  1332.  $vb = new SNMP::Varbind();
  1333.  do {
  1334.     $val = $sess->getnext($vb);
  1335.     print "@{$vb}n";
  1336.  } until ($sess->{ErrorNum});
  1337.  ...
  1338.  $SNMP::save_descriptions = 1;
  1339.  SNMP::initMib(); # assuming mib is not already loaded
  1340.  print "$SNMP::MIB{sysDescr}{description}n";
  1342. =head1 DESCRIPTION
  1345. Note: The perl SNMP 5.0 module which comes with net-snmp 5.0 and
  1346. higher is different than previous versions in a number of ways.  Most
  1347. importantly, it behaves like a proper net-snmp application and calls
  1348. init_snmp properly, which means it will read configuration files and
  1349. use those defaults where appropriate automatically parse MIB files,
  1350. etc.  This will likely affect your perl applications if you have, for
  1351. instance, default values set up in your snmp.conf file (as the perl
  1352. module will now make use of those defaults).  The docmuentation,
  1353. however, has sadly not been updated yet (aside from this note), nor is
  1354. the read_config default usage implementation fully complete.
  1356. The basic operations of the SNMP protocol are provided by this module
  1357. through an object oriented interface for modularity and ease of use.
  1358. The primary class is SNMP::Session which encapsulates the persistent
  1359. aspects of a connection between the management application and the
  1360. managed agent. Internally the class is implemented as a blessed hash
  1361. reference. This class supplies 'get', 'getnext', 'set', 'fget', and
  1362. 'fgetnext' method calls. The methods take a variety of input argument
  1363. formats and support both syncronous and asyncronous operation through
  1364. a polymorphic API (i.e., method behaviour varies dependent on args
  1365. passed - see below).
  1367. =head1 SNMP::Session
  1369. $sess = new SNMP::Session(DestHost => 'host', ...)
  1371. The following arguments may be passed to new as a hash.
  1373. =over 4
  1375. =item DestHost
  1377. default 'localhost', hostname or ip addr of SNMP agent
  1379. =item Community
  1381. default 'public', SNMP community string (used for both R/W)
  1383. =item Version
  1385. default taken from library configuration - probably 3 [1, 2 (same as 2c), 2c, 3]
  1387. =item RemotePort
  1389. default '161', allow remote UDP port to be overriden
  1391. =item Timeout
  1393. default '1000000', micro-seconds before retry
  1395. =item Retries
  1397. default '5', retries before failure
  1399. =item RetryNoSuch
  1401. default '0', if enabled NOSUCH errors in 'get' pdus will
  1402. be repaired, removing the varbind in error, and resent -
  1403. undef will be returned for all NOSUCH varbinds, when set
  1404. to '0' this feature is disabled and the entire get request
  1405. will fail on any NOSUCH error (applies to v1 only)
  1407. =item SecName
  1409. default 'initial', security name (v3)
  1411. =item SecLevel
  1413. default 'noAuthNoPriv', security level [noAuthNoPriv,
  1414. authNoPriv, authPriv] (v3)
  1416. =item SecEngineId
  1418. default <none>, security engineID, will be probed if not
  1419. supplied (v3)
  1421. =item ContextEngineId
  1423. default <SecEngineId>, context engineID, will be
  1424. probed if not supplied (v3)
  1426. =item Context
  1428. default '', context name (v3)
  1430. =item AuthProto
  1432. default 'MD5', authentication protocol [MD5, SHA] (v3)
  1434. =item AuthPass
  1436. default <none>, authentication passphrase
  1438. =item PrivProto
  1440. default 'DES', privacy protocol [DES, AES] (v3)
  1442. =item PrivPass
  1444. default <none>, privacy passphrase (v3)
  1446. =item authMasterKey
  1448. =item privMasterKey
  1450. =item authLocalizedKey
  1452. =item privLocalizedKey
  1454. Directly specified SNMPv3 USM user keys (used if you want to specify
  1455. the keys instead of deriving them from a password as above).
  1457. =item VarFormats
  1459. default 'undef', used by 'fget[next]', holds an hash
  1460. reference of output value formatters, (e.g., {<obj> =>
  1461. <sub-ref>, ... }, <obj> must match the <obj> and format
  1462. used in the get operation. A special <obj>, '*', may be
  1463. used to apply all <obj>s, the supplied sub is called to
  1464. translate the value to a new format. The sub is called
  1465. passing the Varbind as the arg
  1467. =item TypeFormats
  1469. default 'undef', used by 'fget[next]', holds an hash
  1470. reference of output value formatters, (e.g., {<type> =>
  1471. <sub-ref>, ... }, the supplied sub is called to translate
  1472. the value to a new format, unless a VarFormat mathces first
  1473. (e.g., $sess->{TypeFormats}{INTEGER} = &mapEnum();
  1474. although this can be done more efficiently by enabling
  1475. $SNMP::use_enums or session creation param 'UseEnums')
  1477. =item UseLongNames
  1479. defaults to the value of SNMP::use_long_names at time
  1480. of session creation. set to non-zero to have <tags>
  1481. for 'getnext' methods generated preferring longer Mib name
  1482. convention (e.g., system.sysDescr vs just sysDescr)
  1484. =item UseSprintValue
  1486. defaults to the value of SNMP::use_sprint_value at time
  1487. of session creation. set to non-zero to have return values
  1488. for 'get' and 'getnext' methods formatted with the libraries
  1489. snprint_value function. This will result in certain data types
  1490. being returned in non-canonical format Note: values returned
  1491. with this option set may not be appropriate for 'set' operations
  1492. (see discussion of value formats in <vars> description section)
  1494. =item UseEnums
  1496. defaults to the value of SNMP::use_enums at time of session
  1497. creation. set to non-zero to have integer return values
  1498. converted to enumeration identifiers if possible, these values
  1499. will also be acceptable when supplied to 'set' operations
  1501. =item UseNumeric
  1503. defaults to the value of SNMP::use_numeric at time of session
  1504. creation. set to non-zero to have <tags> for get methods returned
  1505. as numeric OID's rather than descriptions.  UseLongNames will be
  1506. set so that the full OID is returned to the caller.
  1508. =item BestGuess
  1510. defaults to the value of SNMP::best_guess at time of session
  1511. creation. this setting controls how <tags> are parsed.  setting to
  1512. 0 causes a regular lookup.  setting to 1 causes a regular expression 
  1513. match (defined as -Ib in snmpcmd) and setting to 2 causes a random 
  1514. access lookup (defined as -IR in snmpcmd).
  1516. =item ErrorStr
  1518. read-only, holds the error message assoc. w/ last request
  1520. =item ErrorNum
  1522. read-only, holds the snmp_err or staus of last request
  1524. =item ErrorInd
  1526. read-only, holds the snmp_err_index when appropriate
  1528. =back
  1530. Private variables:
  1532. =over
  1534. =item DestAddr
  1536. internal field used to hold the translated DestHost field
  1538. =item SessPtr
  1540. internal field used to cache a created session structure
  1542. =back
  1544. =head2 SNMP::Session methods
  1546. =over
  1548. =item $sess->update(E<lt>fieldsE<gt>)
  1550. Updates the SNMP::Session object with the values fields
  1551. passed in as a hash list (similar to new(E<lt>fieldsE<gt>))
  1552. B<(WARNING! not fully implemented)>
  1554. =item $sess->get(E<lt>varsE<gt> [,E<lt>callbackE<gt>])
  1556. do SNMP GET, multiple <vars> formats accepted.
  1557. for syncronous operation <vars> will be updated
  1558. with value(s) and type(s) and will also return
  1559. retrieved value(s). If <callback> supplied method
  1560. will operate asyncronously
  1562. =item $sess->fget(E<lt>varsE<gt> [,E<lt>callbackE<gt>])
  1564. do SNMP GET like 'get' and format the values according
  1565. the handlers specified in $sess->{VarFormats} and
  1566. $sess->{TypeFormats}
  1568. =item $sess->getnext(E<lt>varsE<gt> [,E<lt>callbackE<gt>])
  1570. do SNMP GETNEXT, multiple <vars> formats accepted,
  1571. returns retrieved value(s), <vars> passed as arguments are
  1572. updated to indicate next lexicographical <obj>,<iid>,<val>,
  1573. and <type>
  1575. Note: simple string <vars>,(e.g., 'sysDescr.0')
  1576. form is not updated. If <callback> supplied method
  1577. will operate asyncronously
  1579. =item $sess->fgetnext(E<lt>varsE<gt> [,E<lt>callbackE<gt>])
  1581. do SNMP GETNEXT like getnext and format the values according
  1582. the handlers specified in $sess->{VarFormats} and
  1583. $sess->{TypeFormats}
  1585. =item $sess->set(E<lt>varsE<gt> [,E<lt>callbackE<gt>])
  1587. do SNMP SET, multiple <vars> formats accepted.
  1588. the value field in all <vars> formats must be in a canonical
  1589. format (i.e., well known format) to ensure unambiguous
  1590. translation to SNMP MIB data value (see discussion of
  1591. canonical value format <vars> description section),
  1592. returns snmp_errno. If <callback> supplied method
  1593. will operate asyncronously
  1595. =item $sess->getbulk(E<lt>non-repeatersE<gt>, E<lt>max-repeatersE<gt>, E<lt>varsE<gt>)
  1597. do an SNMP GETBULK, from the list of Varbinds, the single
  1598. next lexico instance is fetched for the first n Varbinds
  1599. as defined by <non-repeaters>. For remaining Varbinds,
  1600. the m lexico instances are retrieved each of the remaining
  1601. Varbinds, where m is <max-repeaters>.
  1603. =item $sess->bulkwalk(E<lt>non-repeatersE<gt>, E<lt>max-repeatersE<gt>, E<lt>varsE<gt> [,E<lt>callbackE<gt>])
  1605. Do a "bulkwalk" of the list of Varbinds.  This is done by
  1606. sending a GETBULK request (see getbulk() above) for the
  1607. Varbinds.  For each requested variable, the response is
  1608. examined to see if the next lexico instance has left the
  1609. requested sub-tree.  Any further instances returned for
  1610. this variable are ignored, and the walk for that sub-tree
  1611. is considered complete.
  1613. If any sub-trees were not completed when the end of the
  1614. responses is reached, another request is composed, consisting
  1615. of the remaining variables.  This process is repeated until
  1616. all sub-trees have been completed, or too many packets have
  1617. been exchanged (to avoid loops).
  1619. The bulkwalk() method returns an array containing an array of
  1620. Varbinds, one for each requested variable, in the order of the
  1621. variable requests.  Upon error, bulkwalk() returns undef and
  1622. sets $sess->ErrorStr and $sess->ErrorNum.  If a callback is
  1623. supplied, bulkwalk() returns the SNMP request id, and returns
  1624. immediately.  The callback will be called with the supplied
  1625. argument list and the returned variables list.
  1627. Note: Because the client must "discover" that the tree is
  1628. complete by comparing the returned variables with those that
  1629. were requested, there is a potential "gotcha" when using the
  1630. max-repeaters value.  Consider the following code to print a
  1631. list of interfaces and byte counts:
  1633.     $numInts = $sess->get('ifNumber.0');
  1634.     ($desc, $in, $out) = $sess->bulkwalk(0, $numInts,
  1635.   [['ifDescr'], ['ifInOctets'], ['ifOutOctets']]);
  1637.     for $i (0..($numInts - 1)) {
  1638.         printf "Interface %4s: %s inOctets, %s outOctetsn",
  1639.                   $$desc[$i]->val, $$in[$i]->val, $$out[$i]->val;
  1640.     }
  1642. This code will produce *two* requests to the agent -- the first
  1643. to get the interface values, and the second to discover that all
  1644. the information was in the first packet.  To get around this,
  1645. use '$numInts + 1' for the max_repeaters value.  This asks the
  1646. agent to include one additional (unrelated) variable that signals
  1647. the end of the sub-tree, allowing bulkwalk() to determine that
  1648. the request is complete.
  1650. =item $results = $sess->gettable(E<lt>TABLE OIDE<gt>, E<lt>OPTIONS<gt>)
  1652. This will retrieve an entire table of data and return a hash reference
  1653. to that data.  The returned hash reference will have indexes of the
  1654. OID suffixes for the index data as the key.  The value for each entry
  1655. will be another hash containing the data for a given row.  The keys to
  1656. that hash will be the column names, and the values will be the data.
  1658. Example:
  1660.   #!/usr/bin/perl
  1662.   use SNMP;
  1663.   use Data::Dumper;
  1665.   my $s = new SNMP::Session(DestHost => 'localhost');
  1667.   print Dumper($s->gettable('ifTable'));
  1669. On my machine produces:
  1671.   $VAR1 = {
  1672.             '6' => {
  1673.                      'ifMtu' => '1500',
  1674.                      'ifPhysAddress' => 'PV',
  1675.                      # ...
  1676.                      'ifInUnknownProtos' => '0'
  1677.                    },
  1678.             '4' => {
  1679.                      'ifMtu' => '1480',
  1680.                      'ifPhysAddress' => '',
  1681.                      # ...
  1682.                      'ifInUnknownProtos' => '0'
  1683.                    },
  1684.             # ...
  1685.            };
  1687. By default, it will try to do as optimized retrieval as possible.
  1688. It'll request multiple columns at once, and use GETBULK if possible.
  1689. A few options may be specified by passing in an I<OPTIONS> hash
  1690. containing various parameters:
  1692. =over
  1694. =item noindexes => 1
  1696. Instructs the code not to parse the indexes and place the results in
  1697. the second hash.  If you don't need the index data, this will be
  1698. faster.
  1700. =item columns => [ colname1, ... ]
  1702. This specifies which columns to collect.  By default, it will try to
  1703. collect all the columns defined in the MIB table.
  1705. =item repeat => I<COUNT>
  1707. Specifies a GETBULK repeat I<COUNT>.  IE, it will request this many
  1708. varbinds back per column when using the GETBULK operation.  Shortening
  1709. this will mean smaller packets which may help going through some
  1710. systems.  By default, this value is calculated and attepmts to guess
  1711. at what will fit all the results into 1000 bytes.  This calculation is
  1712. fairly safe, hopefully, but you can either raise or lower the number
  1713. using this option if desired.  In lossy networks, you want to make
  1714. sure that the packets don't get fragmented and lowering this value is
  1715. one way to help that.
  1717. =item nogetbulk => 1
  1719. Force the use of GETNEXT rather than GETBULK.  (always true for
  1720. SNMPv1, as it doesn't have GETBULK anyway).  Some agents are great
  1721. implementers of GETBULK and this allows you to force the use of
  1722. GETNEXT oprations instead.
  1724. =back
  1726. =back
  1728. =head1 SNMP::TrapSession
  1730. $sess = new SNMP::Session(DestHost => 'host', ...)
  1732. supports all applicable fields from SNMP::Session
  1733. (see above)
  1735. =head2 SNMP::TrapSession methods
  1737. =over
  1739. =item $sess->trap(enterprise, agent, generic, specific, uptime, <vars>)
  1741.     $sess->trap(enterprise=>'.1.3.6.1.4.1.2021', # or 'ucdavis' [default]
  1742.                 agent => '127.0.0.1', # or 'localhost',[dflt 1st intf on host]
  1743.                 generic => specific,  # can be omitted if 'specific' supplied
  1744.                 specific => 5,        # can be omitted if 'generic' supplied
  1745.                 uptime => 1234,       # dflt to localhost uptime (0 on win32)
  1746.                 [[ifIndex, 1, 1],[sysLocation, 0, "here"]]); # optional vars
  1747.                                                              # always last
  1749. =item trap(oid, uptime, <vars>) - v2 format
  1751.     $sess->trap(oid => 'snmpRisingAlarm',
  1752.                 uptime => 1234,
  1753.                 [[ifIndex, 1, 1],[sysLocation, 0, "here"]]); # optional vars
  1754.                                                              # always last
  1756. =back
  1758. =head1 Acceptable variable formats:
  1760. <vars> may be one of the following forms:
  1762. =over
  1764. =item SNMP::VarList
  1766. represents an array of MIB objects to get or set,
  1767. implemented as a blessed reference to an array of
  1768. SNMP::Varbinds, (e.g., [<varbind1>, <varbind2>, ...])
  1770. =item SNMP::Varbind
  1772. represents a single MIB object to get or set, implemented as
  1773. a blessed reference to a 4 element array;
  1774. [<obj>, <iid>, <val>, <type>].
  1776. =over
  1778. =item <obj>
  1780. one of the following forms:
  1782. =over
  1784. =item 1)
  1786. leaf identifier (e.g., 'sysDescr') assumed to be
  1787. unique for practical purposes
  1789. =item 2)
  1791. fully qualified identifier (e.g.,
  1792. '.iso.org.dod.internet.mgmt.mib-2.system.sysDescr')
  1794. =item 3)
  1796. fully qualified, dotted-decimal, numeric OID (e.g.,
  1797. '.1.3.6.1.2.1.1.1')
  1799. =back
  1801. =item <iid>
  1803. the dotted-decimal, instance identifier. for
  1804. scalar MIB objects use '0'
  1806. =item <val>
  1808. the SNMP data value retrieved from or being set
  1809. to the agents MIB. for (f)get(next) operations
  1810. <val> may have a variety of formats as determined by
  1811. session and package settings. However for set
  1812. operations the <val> format must be canonical to
  1813. ensure unambiguous translation. The canonical forms
  1814. are as follows:
  1816. =over
  1818. =item OBJECTID
  1820. dotted-decimal (e.g., .1.3.6.1.2.1.1.1)
  1822. =item OCTETSTR
  1824. perl scalar containing octets
  1826. =item INTEGER
  1828. decimal signed integer (or enum)
  1830. =item NETADDR
  1832. dotted-decimal
  1834. =item IPADDR
  1836. dotted-decimal
  1838. =item COUNTER
  1840. decimal unsigned integer
  1842. =item COUNTER64
  1844. decimal unsigned integer
  1846. =item GAUGE
  1848. decimal unsigned integer
  1850. =item UINTEGER
  1852. decimal unsigned integer
  1854. =item TICKS
  1856. decimal unsigned integer
  1858. =item OPAQUE
  1860. perl scalar containing octets
  1862. =item NULL
  1864. perl scalar containing nothing
  1866. =back
  1868. =item <type>
  1870. SNMP data type (see list above), this field is
  1871. populated by 'get' and 'getnext' operations. In
  1872. some cases the programmer needs to populate this
  1873. field when passing to a 'set' operation. this
  1874. field need not be supplied when the attribute
  1875. indicated by <tag> is already described by loaded
  1876. Mib modules. for 'set's, if a numeric OID is used
  1877. and the object is not currently in the loaded Mib,
  1878. the <type> field must be supplied
  1880. =back
  1882. =item simple string
  1884. light weight form of <var> used to 'set' or 'get' a
  1885. single attribute without constructing an SNMP::Varbind.
  1886. stored in a perl scalar, has the form '<tag>.<iid>',
  1887. (e.g., 'sysDescr.0'). for 'set' operations the value
  1888. is passed as a second arg. Note: This argument form is
  1889. not updated in get[next] operations as are the other forms.
  1891. =back
  1893. =head1 Acceptable callback formats
  1895. <callback> may be one of the following forms:
  1897. =over
  1899. =item without arguments
  1901. =over
  1903. =item &subname
  1905. =item sub { ... }
  1907. =back
  1909. =item or with arguments
  1911. =over
  1913. =item [ &subname, $arg1, ... ]
  1915. =item [ sub { ... }, $arg1, ... ]
  1917. =item [ "method", $obj, $arg1, ... ]
  1919. =back
  1921. =back
  1923. callback will be called when response is received or timeout
  1924. occurs. the last argument passed to callback will be a
  1925. SNMP::VarList reference. In case of timeout the last argument
  1926. will be undef.
  1928. =over
  1930. =item &SNMP::MainLoop([<timeout>, [<callback>]])
  1932. to be used with async SNMP::Session
  1933. calls. MainLoop must be called after initial async calls
  1934. so return packets from the agent will not be processed.
  1935. If no args suplied this function enters an infinite loop
  1936. so program must be exited in a callback or externally
  1937. interupted. If <timeout(sic)
  1939. =item &SNMP::finish()
  1941. This function, when called from an SNMP::MainLoop() callback
  1942. function, will cause the current SNMP::MainLoop() to return
  1943. after the callback is completed.  finish() can be used to
  1944. terminate an otherwise-infinite MainLoop.  A new MainLoop()
  1945. instance can then be started to handle further requests.
  1947. =back
  1949. =head1 SNMP package variables and functions
  1951. =over
  1953. =item $SNMP::VERSION
  1955. the current version specifier (e.g., 3.1.0)
  1957. =item $SNMP::auto_init_mib
  1959. default '1', set to 0 to disable automatic reading
  1960. of the MIB upon session creation. set to non-zero
  1961. to call initMib at session creation which will result
  1962. in MIB loading according to UCD env. variables (see
  1963. man mib_api)
  1965. =item $SNMP::verbose
  1967. default '0', controls warning/info output of
  1968. SNMP module, 0 => no output, 1 => enables warning/info
  1969. output from SNMP module itself (is also controlled
  1970. by SNMP::debugging - see below)
  1972. =item $SNMP::use_long_names
  1974. default '0', set to non-zero to enable the use of
  1975. longer Mib identifiers. see translateObj. will also
  1976. influence the formatting of <tag> in varbinds returned
  1977. from 'getnext' operations. Can be set on a per session
  1978. basis (UseLongNames)
  1980. =item $SNMP::use_sprint_value
  1982. default '0', set to non-zero to enable formatting of
  1983. response values using the snmp libraries snprint_value
  1984. function. can also be set on a per session basis (see
  1985. UseSprintValue) Note: returned values may not be
  1986. suitable for 'set' operations
  1988. =item $SNMP::use_enums
  1990. default '0',set non-zero to return values as enums and
  1991. allow sets using enums where appropriate. integer data
  1992. will still be accepted for set operations. can also be
  1993. set on a per session basis (see UseEnums)
  1995. =item $SNMP::use_numeric
  1997. default to '0',set to non-zero to have <tags> for 'get'
  1998. methods returned as numeric OID's rather than descriptions.
  1999. UseLongNames will be set so that the entire OID will be
  2000. returned.  Set on a per-session basis (see UseNumeric).
  2002. =item $SNMP::best_guess
  2004. default '0'.  This setting controls how <tags> are 
  2005. parsed.  Setting to 0 causes a regular lookup.  Setting 
  2006. to 1 causes a regular expression match (defined as -Ib 
  2007. in snmpcmd) and setting to 2 causes a random access 
  2008. lookup (defined as -IR in snmpcmd).  Can also be set 
  2009. on a per session basis (see BestGuess)
  2011. =item $SNMP::save_descriptions
  2013. default '0',set non-zero to have mib parser save
  2014. attribute descriptions. must be set prior to mib
  2015. initialization
  2017. =item $SNMP::debugging
  2019. default '0', controlls debugging output level
  2020. within SNMP module and libsnmp
  2022. =over
  2024. =item 1
  2026. enables 'SNMP::verbose' (see above)
  2028. =item 2
  2030. level 1 plus snmp_set_do_debugging(1)
  2032. =item 3
  2034. level 2 plus snmp_set_dump_packet(1)
  2036. =back
  2038. =item $SNMP::dump_packet
  2040. default '0', set [non-]zero to independently set
  2041. snmp_set_dump_packet()
  2043. =back
  2045. =head1 %SNMP::MIB
  2047. a tied hash to access parsed MIB information. After
  2048. the MIB has been loaded this hash allows access to
  2049. to the parsed in MIB meta-data(the structure of the
  2050. MIB (i.e., schema)). The hash returns blessed
  2051. references to SNMP::MIB::NODE objects which represent
  2052. a single MIB attribute. The nodes can be fetched with
  2053. multiple 'key' formats - the leaf name (e.g.,sysDescr)
  2054. or fully/partially qualified name (e.g.,
  2055. system.sysDescr) or fully qualified numeric OID. The
  2056. returned node object supports the following fields:
  2058. =over
  2060. =item objectID
  2062. dotted decimal fully qualified OID
  2064. =item label
  2066. leaf textual identifier (e.g., 'sysDescr')
  2068. =item subID
  2070. leaf numeric OID component of objectID (e.g., '1')
  2072. =item moduleID
  2074. textual identifier for module (e.g., 'RFC1213-MIB')
  2076. =item parent
  2078. parent node
  2080. =item children
  2082. array reference of children nodes
  2084. =item nextNode
  2086. next lexico node B<(BUG!does not return in lexico order)>
  2088. =item type
  2090. returns application type (see getType for values)
  2092. =item access
  2094. returns ACCESS (ReadOnly, ReadWrite, WriteOnly,
  2095. NoAccess, Notify, Create)
  2097. =item status
  2099. returns STATUS (Mandatory, Optional, Obsolete,
  2100. Deprecated)
  2102. =item syntax
  2104. returns 'textualConvention' if defined else 'type'
  2106. =item textualConvention
  2108. returns TEXTUAL-CONVENTION
  2110. =item TCDescription
  2112. returns the TEXTUAL-CONVENTION's DESCRIPTION field.
  2114. =item units
  2116. returns UNITS
  2118. =item hint
  2120. returns HINT
  2122. =item enums
  2124. returns hash ref {tag => num, ...}
  2126. =item ranges
  2128. returns array ref of hash ref [{low => num, high => num}, ...]
  2130. =item description
  2132. returns DESCRIPTION ($SNMP::save_descriptions must
  2133. be set prior to MIB initialization/parsing)
  2135. =item reference
  2137. returns the REFERENCE clause
  2139. =back
  2141. =head1 MIB Functions
  2143. =over
  2145. =item &SNMP::setMib(<file>)
  2147. allows dynamic parsing of the mib and explicit
  2148. specification of mib file independent of enviroment
  2149. variables. called with no args acts like initMib,
  2150. loading MIBs indicated by environment variables (see
  2151. ucd mib_api docs). passing non-zero second arg
  2152. forces previous mib to be freed and replaced
  2153. B<(Note: second arg not working since freeing previous
  2154. Mib is more involved than before)>.
  2156. =item &SNMP::initMib()
  2158. calls library init_mib function if Mib not already
  2159. loaded - does nothing if Mib already loaded. will
  2160. parse directories and load modules according to
  2161. environment variables described in UCD documentations.
  2162. (see man mib_api, MIBDIRS, MIBS, MIBFILE(S), etc.)
  2164. =item &SNMP::addMibDirs(<dir>,...)
  2166. calls library add_mibdir for each directory
  2167. supplied. will cause directory(s) to be added to
  2168. internal list and made available for searching in
  2169. subsequent loadModules calls
  2171. =item &SNMP::addMibFiles(<file>,...)
  2173. calls library read_mib function. The file(s)
  2174. supplied will be read and all Mib module definitions
  2175. contained therein will be added to internal mib tree
  2176. structure
  2178. =item &SNMP::loadModules(<mod>,...)
  2180. calls library read_module function. The
  2181. module(s) supplied will be searched for in the
  2182. current mibdirs and and added to internal mib tree
  2183. structure. Passing special <mod>, 'ALL', will cause
  2184. all known modules to be loaded.
  2186. =item &SNMP::unloadModules(<mod>,...)
  2188. B<*Not Implemented*>
  2190. =item &SNMP::translateObj(<var>[,arg,[arg]])
  2192. will convert a text obj tag to an OID and vice-versa.
  2193. Any iid suffix is retained numerically.  Default
  2194. behaviour when converting a numeric OID to text
  2195. form is to return leaf identifier only 
  2196. (e.g.,'sysDescr') but when $SNMP::use_long_names 
  2197. is non-zero or a non-zero second arg is supplied it 
  2198. will return a longer textual identifier.  An optional 
  2199. third argument of non-zero will cause the module name 
  2200. to be prepended to the text name (e.g. 
  2201. 'SNMPv2-MIB::sysDescr').  When converting a text obj, 
  2202. the $SNMP::best_guess option is used.  If no Mib is 
  2203. loaded when called and $SNMP::auto_init_mib is enabled 
  2204. then the Mib will be loaded. Will return 'undef' upon 
  2205. failure.
  2207. =item &SNMP::getType(<var>)
  2209. return SNMP data type for given textual identifier
  2210. OBJECTID, OCTETSTR, INTEGER, NETADDR, IPADDR, COUNTER
  2211. GAUGE, TIMETICKS, OPAQUE, or undef
  2213. =item &SNMP::mapEnum(<var>)
  2215. converts integer value to enumertion tag defined
  2216. in Mib or converts tag to integer depending on
  2217. input. the function will return the corresponding
  2218. integer value *or* tag for a given MIB attribute
  2219. and value. The function will sense which direction
  2220. to perform the conversion. Various arg formats are
  2221. supported
  2223. =over
  2225. =item $val = SNMP::mapEnum($varbind);
  2227. where $varbind is SNMP::Varbind or equiv.
  2228. note: $varbind will be updated
  2230. =item $val = SNMP::mapEnum('ipForwarding', 'forwarding');
  2232. =item $val = SNMP::mapEnum('ipForwarding', 1);
  2234. =back
  2236. =back
  2238. =head1 Exported SNMP utility functions
  2240. Note: utility functions do not support async operation yet.
  2242. =over
  2244. =item &snmp_get()
  2246. takes args of SNMP::Session::new followed by those of
  2247. SNMP::Session::get
  2249. =item &snmp_getnext()
  2251. takes args of SNMP::Session::new followed by those of
  2252. SNMP::Session::getnext
  2254. =item &snmp_set()
  2256. takes args of SNMP::Session::new followed by those of
  2257. SNMP::Session::set
  2259. =item &snmp_trap()
  2261. takes args of SNMP::TrapSession::new followed by those of
  2262. SNMP::TrapSession::trap
  2264. =back
  2266. =head1 Trouble Shooting
  2268. If problems occur there are number areas to look at to narrow down the
  2269. possibilities.
  2271. The first step should be to test the UCD SNMP installation
  2272. independently from the Perl5 SNMP interface.
  2274. Try running the apps from the UCD SNMP distribution.
  2276. Make sure your agent (snmpd) is running and properly configured with
  2277. read-write access for the community you are using.
  2279. Ensure that your MIBs are installed and enviroment variables are set
  2280. appropriately (see man mib_api)
  2282. Be sure to remove old ucd-snmp installations and ensure headers and
  2283. libraries from old CMU installations are not being used by mistake.
  2285. If the problem occurs during compilation/linking check that the snmp
  2286. library being linked is actually the UCD SNMP library (there have been
  2287. name conflicts with existing snmp libs).
  2289. Also check that the header files are correct and up to date.
  2291. Sometimes compiling the UCD SNMP library with
  2292. 'position-independent-code' enabled is required (HPUX specifically).
  2294. If you cannot resolve the problem you can post to
  2295. comp.lang.perl.modules or
  2296. net-snmp-users@net-snmp-users@lists.sourceforge.net
  2298. please give sufficient information to analyze the problem (OS type,
  2299. versions for OS/Perl/UCD/compiler, complete error output, etc.)
  2301. =head1 Acknowledgements
  2303. Many thanks to all those who supplied patches, suggestions and
  2304. feedback.
  2306.  Joe Marzot (the original author)
  2307.  Wes Hardaker and the net-snmp-coders
  2308.  Dave Perkins
  2309.  Marcel Wiget
  2310.  David Blackburn
  2311.  John Stofell
  2312.  Gary Hayward
  2313.  Claire Harrison
  2314.  Achim Bohnet
  2315.  Doug Kingston
  2316.  Jacques Vidrine
  2317.  Carl Jacobsen
  2318.  Wayne Marquette
  2319.  Scott Schumate
  2320.  Michael Slifcak
  2321.  Srivathsan Srinivasagopalan
  2322.  Bill Fenner
  2323.  Jef Peeraer
  2324.  Daniel Hagerty
  2325.  Karl "Rat" Schilke and Electric Lightwave, Inc.
  2326.  Perl5 Porters
  2327.  Alex Burger
  2329. Apologies to any/all who's patch/feature/request was not mentioned or
  2330. included - most likely it was lost when paying work intruded on my
  2331. fun. Please try again if you do not see a desired feature. This may
  2332. actually turn out to be a decent package with such excellent help and
  2333. the fact that I have more time to work on it than in the past.
  2335. =head1 AUTHOR
  2337. bugs, comments, questions to net-snmp-users@lists.sourceforge.net
  2339. =head1 Copyright
  2341.      Copyright (c) 1995-2000 G. S. Marzot. All rights reserved.
  2342.      This program is free software; you can redistribute it and/or
  2343.      modify it under the same terms as Perl itself.
  2345.      Copyright (c) 2001-2002 Networks Associates Technology, Inc.  All
  2346.      Rights Reserved.  This program is free software; you can
  2347.      redistribute it and/or modify it under the same terms as Perl
  2348.      itself.
  2350. =cut