snmp_util.pm

动态域名解决方案。类似windows下的花生壳。代码用perl编写

    while ($bindings) {
      ($binding, $bindings) = decode_sequence($bindings);
      ($oid, $value) = decode_by_template($binding, "%O%@");
      my $tempo = pretty_print($oid);
      my $tempv = pretty_print($value);
      push @retvals, "$tempo:$tempv";
    }
    return (@retvals);
  } else {
    $var = join(' ', @vars);
    carp "SNMPGETBULK Problem for $var on $host\n"
      unless ($SNMP_Session::suppress_warnings > 1);
    return undef;
  }
}

#
# walk a table, calling a user-supplied function for each
# column of a table.
#
sub snmpmaptable($$@) {
  my($host, $fun, @vars) = @_;
  my(@enoid, $var, $session);

  $session = &snmpopen($host, 0, \@vars);
  if (!defined($session)) {
    carp "SNMPMAPTABLE Problem for $host\n"
      unless ($SNMP_Session::suppress_warnings > 1);
    return undef;
  }

  foreach $var (toOID(@vars)) {
    push(@enoid, [split('\.', pretty_print($var))]);
  }

  return $session->map_table([@enoid],
			      sub() {
				my ($ind, @vals) = @_;
				my (@pvals, $val);

				foreach $val (@vals) {
				  push(@pvals, pretty_print($val));
				}
				&$fun($ind, @pvals);
			      }
			      );
}

#
# Walk the MIB, puting everything you find into hashes.
#
sub snmpwalkhash($$@) {
  my($host, $hash_sub, @vars) = @_;
  my($retflg, @retvals, %revOID, $ret, $tempo, $tempv, %rethash);

  @retvals = snmpwalk_flg($host, 1, @vars);

  %revOID = reverse %SNMP_util::OIDS;
  foreach $ret (@retvals) {
    my $inst;
    ($tempo, $tempv) = split(':', $ret);
    while (!exists($revOID{$tempo}) && length($tempo)) {
      $tempo =~ s/(\.\d+?)$//;
      $inst = $1.$inst;
    }
    if (defined($hash_sub)) {
      &$hash_sub(\%rethash, $host, $revOID{$tempo}, $tempo, $inst, $tempv);
    } else {
      $rethash{$tempo}{$inst} = $tempv;
    }
  }
  return(%rethash);
}

#
#  Given an OID in either ASN.1 or mixed text/ASN.1 notation, return an
#  encoded OID.
#
sub toOID(@) {
  my(@vars) = @_;
  my($oid, $var, $tmp, $tmpv, @retvar);

  undef @retvar;
  foreach $var (@vars) {
    ($oid, $tmp) = &Check_OID($var);
    if (!$oid && $SNMP_util::CacheLoaded == 0) {
      $tmp = $SNMP_Session::suppress_warnings;
      $SNMP_Session::suppress_warnings = 1000;

      &snmpLoad_OID_Cache($SNMP_util::CacheFile);

      $SNMP_util::CacheLoaded = 1;
      $SNMP_Session::suppress_warnings = $tmp;

      ($oid, $tmp) = &Check_OID($var);
    }
    while (!$oid && $#SNMP_util::MIB_Files >= 0) {
      $tmp = $SNMP_Session::suppress_warnings;
      $SNMP_Session::suppress_warnings = 1000;

      snmpMIB_to_OID(shift(@SNMP_util::MIB_Files));

      $SNMP_Session::suppress_warnings = $tmp;

      ($oid, $tmp) = &Check_OID($var);
      if ($oid) {
	open(CACHE, ">>$SNMP_util::CacheFile");
	print CACHE "$tmp\t$oid\n";
	close(CACHE);
      }
    }
    if ($oid) {
      $var =~ s/^$tmp/$oid/;
    } else {
      carp "Unknown SNMP var $var\n"
      unless ($SNMP_Session::suppress_warnings > 1);
      next;
    }
    print "toOID: $var\n" if $SNMP_util::Debug;
    $tmp = encode_oid_with_errmsg($var);
    return undef unless defined $tmp;
    push(@retvar, $tmp);
  }
  return @retvar;
}

#
#  Add passed-in text, OID pairs to the OID mapping table.
#
sub snmpmapOID(@)
{
  my(@vars) = @_;
  my($oid, $txt, $ind);

  $ind = 0;
  while($ind <= $#vars) {
    $txt = $vars[$ind++];
    next unless($txt =~ /^(([a-z][a-z\d\-]*\.)*([a-z][a-z\d\-]*))$/i);

    $oid = $vars[$ind++];
    next unless($oid =~ /^((\d+.)*\d+)$/);

    $SNMP_util::OIDS{$txt} = $oid;
    print "snmpmapOID: $txt => $oid\n" if $SNMP_util::Debug;
  }
  return undef;
}

#
# Open the passed-in file name and read it in to populate
# the cache of text-to-OID map table.  It expects lines
# with two fields, the first the textual string like "ifInOctets",
# and the second the OID value, like "1.3.6.1.2.1.2.2.1.10".
#
# blank lines and anything after a '#' or between '--' is ignored.
#
sub snmpLoad_OID_Cache ($) {
  my($arg) = @_;
  my($txt, $oid);

  if (!open(CACHE, $arg)) {
    carp "snmpLoad_OID_Cache: Can't open $arg: $!"
      unless ($SNMP_Session::suppress_warnings > 1);
    return -1;
  }

  while(<CACHE>) {
    s/#.*//;
    s/--.*--//g;
    s/--.*//;
    next if (/^$/);
    next unless (/\s/);
    chop;
    ($txt, $oid) = split(' ', $_, 2);
    &snmpmapOID($txt, $oid);
  }
  close(CACHE);
  return 0;
}

#
# Check to see if an OID is in the text-to-OID cache.
# Returns the OID and the corresponding text as two separate
# elements.
#
sub Check_OID ($) {
  my($var) = @_;
  my($tmp, $tmpv, $oid);

  if ($var =~ /^(([a-z][a-z\d\-]*\.)*([a-z][a-z\d\-]*))/i)
  {
    $tmp = $&;
    $tmpv = $tmp;
    for (;;) {
      last if defined($SNMP_util::OIDS{$tmpv});
      last if !($tmpv =~ s/^[^\.]*\.//);
    }
    $oid = $SNMP_util::OIDS{$tmpv};
    if ($oid) {
      return ($oid, $tmp);
    } else {
      return undef;
    }
  }
  return ($var, $var);
}

#
# Save the passed-in list of MIB files until an OID can't be
# found in the existing table.  At that time the MIB file will
# be loaded, and the lookup attempted again.
#
sub snmpQueue_MIB_File (@) {
  my(@files) = @_;
  my($file);

  foreach $file (@files) {
    push(@SNMP_util::MIB_Files, $file);
  }
}

#
# Read in the passed list of MIB files, parsing them
# for their text-to-OID mappings
#
sub snmpMIB_to_OID ($) {
  my($arg) = @_;
  my($quote, $buf, $var, $code, $val, $tmp, $tmpv, $strt);
  my($ret);
  my(%Link) = (
    'org' => 'iso',
    'dod' => 'org',
    'internet' => 'dod',
    'directory' => 'internet',
    'mgmt' => 'internet',
    'mib-2' => 'mgmt',
    'experimental' => 'internet',
    'private' => 'internet',
    'enterprises' => 'private',
  );

  if (!open(MIB, $arg)) {
    carp "snmpMIB_to_OID: Can't open $arg: $!"
      unless ($SNMP_Session::suppress_warnings > 1);
    return -1;
  }
  print "snmpMIB_to_OID: loading $arg\n" if $SNMP_util::Debug;
  $ret = 0;
  while(<MIB>) {
    s/--.*--//g;	# throw away comments (-- anything --)
    s/--.*//;		# throw away comments (-- anything EOL)
    if ($quote) {
      next unless /"/;
      $quote = 0;
    }
    chop;
#
#	$buf = "$buf $_";
# Previous line removed (and following replacement)
# suggested by Brian Reichert, [e-mail]
#
    $buf .= ' ' . $_;
    $buf =~ s/\s+/ /g;

    if ($buf =~ / DEFINITIONS ::= BEGIN/) {
      undef %Link;
      %Link = (
	'org' => 'iso',
	'dod' => 'org',
	'internet' => 'dod',
	'directory' => 'internet',
	'mgmt' => 'internet',
	'mib-2' => 'mgmt',
	'experimental' => 'internet',
	'private' => 'internet',
	'enterprises' => 'private',
      );
    }

    $buf =~ s/OBJECT-TYPE/OBJECT IDENTIFIER/;
    $buf =~ s/OBJECT-IDENTITY/OBJECT IDENTIFIER/;
    $buf =~ s/MODULE-IDENTITY/OBJECT IDENTIFIER/;
    $buf =~ s/ IMPORTS .*\;//;
    $buf =~ s/ SEQUENCE {.*}//;
    $buf =~ s/ SYNTAX .*//;
    $buf =~ s/ [\w-]+ ::= OBJECT IDENTIFIER//;
    $buf =~ s/ OBJECT IDENTIFIER .* ::= {/ OBJECT IDENTIFIER ::= {/;
    $buf =~ s/".*"//;
    if ($buf =~ /"/) {
      $quote = 1;
    }

    if ($buf =~ / ([\w\-]+) OBJECT IDENTIFIER ::= {([^}]+)}/) {
      $var = $1;
      $buf = $2;
      undef $val;
      $buf =~ s/ +$//;
      ($code, $val) = split(' ', $buf, 2);

      if (!defined($val) || (length($val) <= 0)) {
	$SNMP_util::OIDS{$var} = $code;
	$ret++;
	print "'$var' => '$code'\n" if $SNMP_util::Debug;
      } else {
	$strt = $code;
	while($val =~ / /) {
	  ($tmp, $val) = split(' ', $val, 2);
	  if ($tmp =~ /([\w\-]+)\((\d+)\)/) {
	    $tmp = $1;
	    $tmpv = "$SNMP_util::OIDS{$strt}.$2";
	    $Link{$tmp} = $strt;
	    if (defined($SNMP_util::OIDS{$tmp})) {
	      if ($tmpv ne $SNMP_util::OIDS{$tmp}) {
		$strt = "$strt.$tmp";
		$SNMP_util::OIDS{$strt} = $tmpv;
		$ret++;
	      }
	    } else {
	      $SNMP_util::OIDS{$tmp} = $tmpv;
	      $ret++;
	      $strt = $tmp;
	    }
	  }
	}

	if (!defined($SNMP_util::OIDS{$strt})) {
	  carp "snmpMIB_to_OID: $arg: \"$strt\" prefix unknown, load the parent MIB first.\n"
	    unless ($SNMP_Session::suppress_warnings > 1);
	}
	$Link{$var} = $strt;
	$val = "$SNMP_util::OIDS{$strt}.$val";
	if (defined($SNMP_util::OIDS{$var})) {
	  if ($val ne $SNMP_util::OIDS{$var}) {
	    $var = "$strt.$var";
	  }
	}

	$SNMP_util::OIDS{$var} = $val;
	$ret++;

	print "'$var' => '$val'\n" if $SNMP_util::Debug;
      }
      undef $buf;
    }
  }
  close(MIB);
  return $ret;
}

sub encode_oid_with_errmsg ($) {
  my ($oid) = @_;
  my $tmp = encode_oid(split(/\./, $oid));
  if (! defined $tmp) {
    carp "cannot encode Object ID $oid: $BER::errmsg"
      unless ($SNMP_Session::suppress_warnings > 1);
    return undef;
  }
  return $tmp;
}

1;