view release on metacpan or  search on metacpan

lib/SNMP_util.pm  view on Meta::CPAN

  my($noid);
  my $session;

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

  @enoid = &toOID(@vars);
  if ($#enoid < 0) {
    return wantarray ? @retvals : undef;
  }

  undef @vars;
  undef @retvals;
  foreach $noid (@enoid) {
    $upoid = pretty_print($noid);
    push(@vars, $upoid);
  }
  if ($session->getnext_request_response(@enoid)) {
    $response = $session->pdu_buffer;
    ($bindings) = $session->decode_get_response($response);
    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 wantarray ? @retvals : $retvals[0];
  } else {
    $var = join(' ', @vars);
    carp "SNMPGETNEXT Problem for $var on $host\n"
      unless ($SNMP_Session::suppress_warnings > 1);
    return wantarray ? @retvals : undef;
  }
}

#
# A restricted snmpwalk.
#
sub snmpwalk ($@) {
  my($host, @vars) = @_;
  return(&snmpwalk_flg($host, undef, @vars));
}

#
# Walk the MIB, putting everything you find into hashes.
#
sub snmpwalkhash($$@) {
#  my($host, $hash_sub, @vars) = @_;
  return(&snmpwalk_flg( @_ ));
}

sub snmpwalk_flg ($$@) {
  my($host, $hash_sub, @vars) = @_;
  my(@enoid, $var, $response, $bindings, $binding);
  my($value, $upoid, $oid, @retvals, @retvaltmprefs);
  my($got, @nnoid, $noid, $ok, $ix, @avars);
  my $session;
  my(%soid);
  my(%done, %rethash, $h_ref);

  $h_ref = (ref $vars[$#vars] eq "HASH") ? pop(@vars) : \%rethash;

  $session = &snmpopen($host, 0, \@vars);
  if (!defined($session)) {
    carp "SNMPWALK Problem for $host\n"
      unless ($SNMP_Session::suppress_warnings > 1);
    if (defined($hash_sub)) {
      return ($h_ref) if ($SNMP_util::Return_hash_refs);
      return (%$h_ref);
    } else {
      @retvals = ();
      return (@retvals);
    }
  }

  @enoid = toOID(@vars);
  if ($#enoid < 0) {
    if (defined($hash_sub)) {
      return ($h_ref) if ($SNMP_util::Return_hash_refs);
      return (%$h_ref);
    } else {
      @retvals = ();
      return (@retvals);
    }
  }

  # GIL
  #
  # Create/Refresh a reversed hash with oid -> name
  #
  if (defined($hash_sub) and ($RevNeeded)) {
      %revOIDS = reverse %SNMP_util::OIDS;
      $RevNeeded = 0;
  }

  $got = 0;
  @nnoid = @enoid;
  undef @vars;
  foreach $noid (@enoid) {
    $upoid = pretty_print($noid);
    push(@vars, $upoid);
  }

  # @vars is the original set of walked variables.
  # @avars is the current set of walked variables as the
  # walk goes on.
  # @vars stays static while @avars may shrink as we reach end
  # of walk for individual variables during PDU exchange.
   
  @avars = @vars;

  # IlvJa
  #
  # Create temporary array of refs to return vals.

  if ($SNMP_util::Return_array_refs) {
    for($ix = 0;$ix < scalar @vars; $ix++) {
      my $tmparray = [];
      $retvaltmprefs[$ix] = $tmparray;
      $retvals[$ix] = $tmparray;
    }
  }


  while(($SNMP_util::Version ne '1' and $session->{'use_getbulk'})
    ? $session->getbulk_request_response(0,
					  $session->default_max_repetitions(),
					  @nnoid)
    : $session->getnext_request_response(@nnoid))
  {
    $got = 1;
    $response = $session->pdu_buffer;
    ($bindings) = $session->decode_get_response($response);
    $ix = 0;
    while ($bindings) {
      ($binding, $bindings) = decode_sequence($bindings);
      unless ($nnoid[$ix]) { # IlvJa
	$ix = ++$ix % (scalar @avars);
	next;
      }
      ($oid, $value) = decode_by_template($binding, "%O%@");
      $ok = 0;
      my $tempo = pretty_print($oid);
      $noid = $avars[$ix];  # IlvJa
      if ($tempo =~ /^$noid\./ or $tempo eq $noid ) {
	$ok = 1;
	$upoid = $noid;
      } else {
	# IlvJa
	#
	# The walk for variable $vars[$ix] has been finished as
	# $nnoid[$ix] no longer is in the $avar[$ix] OID tree.
	# So we exclude this variable from further requests.

	$avars[$ix] = "";
	$nnoid[$ix] = "";
	$retvaltmprefs[$ix] = undef if $SNMP_util::Return_array_refs;
      }
      if ($ok) {
	my $tmp = encode_oid_with_errmsg ($tempo);
	if (!defined $tmp) {
	  if (defined($hash_sub)) {
	    return ($h_ref) if ($SNMP_util::Return_hash_refs);
	    return (%$h_ref);
	  } else {
	    @retvals = ();
	    return (@retvals);
	  }
	}
	if (exists($done{$tmp})) {	# GIL, Ilvja
	  #
	  # We've detected a loop for $nnoid[$ix], so mark it as finished.
	  # Exclude this variable from further requests.
	  #
	  $avars[$ix] = "";
	  $nnoid[$ix] = "";
	  $retvaltmprefs[$ix] = undef if $SNMP_util::Return_array_refs;
	  next;
	}
	$nnoid[$ix] = $tmp;   # Keep on walking. (IlvJa)
	my $tempv = pretty_print($value);
	if (defined($hash_sub)) {
	  #
	  # extract name of the oid, if possible, the rest becomes the instance
	  #
	  my $inst = "";
	  my $upo = $upoid;
	  while (!exists($revOIDS{$upo}) and length($upo)) {
	    $upo =~ s/(\.\d+?)$//;
	    if (defined($1) and length($1)) {
	      $inst = $1 . $inst;
	    } else {
	      $upo = "";
	      last;
	    }
	  }	
	  if (length($upo) and exists($revOIDS{$upo})) {
	    $upo = $revOIDS{$upo} . $inst;
	  } else {
	    $upo = $upoid;
	  }

	  $inst = "";
	  while (!exists($revOIDS{$tempo}) and length($tempo)) {
	    $tempo =~ s/(\.\d+?)$//;
	    if (defined($1) and length($1)) {
	      $inst = $1 . $inst;
	    } else {
	      $tempo = "";
	      last;
	    }
	  }	
	  if (length($tempo) and exists($revOIDS{$tempo})) {
	    $var = $revOIDS{$tempo};
	  } else {
	    $var = pretty_print($oid);
	  }
	  #
	  # call hash_sub
	  #
	  &$hash_sub($h_ref, $host, $var, $tempo, $inst,
			$tempv, $upo);
	} else {
	  if ($SNMP_util::Return_array_refs) {
	    $tempo=~s/^$upoid\.//;
	    push @{$retvaltmprefs[$ix]}, "$tempo:$tempv";
	  } else {
	    $tempo=~s/^$upoid\.// if ($#enoid <= 0);
	    push @retvals, "$tempo:$tempv";
	  }
	}
	$done{$tmp} = 1;	# GIL
      }
      $ix = ++$ix % (scalar @avars);
    }

    # Ok, @nnoid should contain the remaining variables for the
    # next request.  Some or all entries in @nnoid might be the empty
    # string.  If the nth element in @nnoid is "" that means that
    # the walk related to the nth variable in the last request has been
    # completed and we should not include that var in subsequent reqs.

    # Clean up both @nnoid and @avars so "" elements are removed.
    @nnoid = grep (($_), @nnoid);
    @avars = grep (($_), @avars);
    @retvaltmprefs = grep (($_), @retvaltmprefs);

    last if ($#nnoid < 0);   # @nnoid empty means we are done walking.
  }
  if (!$got) {
    $var = join(' ', @vars);
    carp "SNMPWALK Problem for $var on $host\n"
      unless ($SNMP_Session::suppress_warnings > 1);
    @retvals = ();
  }
  if (defined($hash_sub)) {
      return ($h_ref) if ($SNMP_util::Return_hash_refs);
      return (%$h_ref);
  } else {
      return (@retvals);
  }
}

#
# A restricted snmpset.
#
sub snmpset($@) {
  my($host, @vars) = @_;
  my(@enoid, $response, $bindings, $binding);
  my($oid, @retvals, $type, $value, $val);
  my $session;

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

  while(@vars) {
    ($oid) = toOID((shift @vars));
    $type  = shift @vars;
    $value = shift @vars;
    $type =~ tr/A-Z/a-z/;
    if ($type eq "int") {
      $val = encode_int($value);
    } elsif ($type eq "integer") {
      $val = encode_int($value);
    } elsif ($type eq "string") {
      $val = encode_string($value);
    } elsif ($type eq "octetstring") {
      $val = encode_string($value);
    } elsif ($type eq "octet string") {
      $val = encode_string($value);
    } elsif ($type eq "oid") {
      $val = encode_oid_with_errmsg($value);
    } elsif ($type eq "object id") {
      $val = encode_oid_with_errmsg($value);
    } elsif ($type eq "object identifier") {
      $val = encode_oid_with_errmsg($value);
    } elsif ($type eq "ipaddr") {
      $val = encode_ip_address($value);
    } elsif ($type eq "ip address") {
      $val = encode_ip_address($value);
    } elsif ($type eq "timeticks") {