EVOLUTION-MANAGER

Edit File: PDU.pm

# -*- mode: perl -*-
# ============================================================================

package Net::SNMP::PDU;

# $Id: PDU.pm,v 3.1 2010/09/10 00:01:22 dtown Rel $

# Object used to represent a SNMP PDU.

# This program is free software; you may redistribute it and/or modify it
# under the same terms as the Perl 5 programming language system itself.

# ============================================================================

use strict;

use Net::SNMP::Message qw( 
   :types :versions asn1_itoa ENTERPRISE_SPECIFIC TRUE FALSE DEBUG_INFO 
);

use Net::SNMP::Transport qw( DOMAIN_UDPIPV4 DOMAIN_TCPIPV4 );

## Version of the Net::SNMP::PDU module

our $VERSION = v3.0.1;

## Handle importing/exporting of symbols

use base qw( Net::SNMP::Message );

sub import
{
   return Net::SNMP::Message->export_to_level(1, @_);
}

# [public methods] -----------------------------------------------------------

sub new
{
   my $class = shift;

# We play some games here to allow us to "convert" a Message into a PDU.

my $this = ref($_[0]) ? bless shift(@_), $class : $class->SUPER::new();

# Override or initialize fields inherited from the base class

$this->{_error_status}   = 0;
   $this->{_error_index}    = 0;
   $this->{_scoped}         = FALSE;
   $this->{_var_bind_list}  = undef;
   $this->{_var_bind_names} = [];
   $this->{_var_bind_types} = undef;

my (%argv) = @_;

# Validate the passed arguments

for (keys %argv) {

if (/^-?callback$/i) {
         $this->callback($argv{$_});
      } elsif (/^-?contextengineid/i) {
         $this->context_engine_id($argv{$_});
      } elsif (/^-?contextname/i) {
         $this->context_name($argv{$_});
      } elsif (/^-?debug$/i) {
         $this->debug($argv{$_});
      } elsif (/^-?leadingdot$/i) {
         $this->leading_dot($argv{$_});
      } elsif (/^-?maxmsgsize$/i) {
         $this->max_msg_size($argv{$_});
      } elsif (/^-?requestid$/i) {
         $this->request_id($argv{$_});
      } elsif (/^-?security$/i) {
         $this->security($argv{$_});
      } elsif (/^-?translate$/i) {
         $this->{_translate} = $argv{$_};
      } elsif (/^-?transport$/i) {
         $this->transport($argv{$_});
      } elsif (/^-?version$/i) {
         $this->version($argv{$_});
      } else {
         $this->_error('The argument "%s" is unknown', $_);
      }

if (defined $this->{_error}) {
         return wantarray ? (undef, $this->{_error}) : undef;
      }

}

if (!defined $this->{_transport}) {
      $this->_error('The Transport Domain object is not defined');
      return wantarray ? (undef, $this->{_error}) : undef;
   }

return wantarray ? ($this, q{}) : $this;
}

sub prepare_get_request
{
   my ($this, $oids) = @_;

$this->_error_clear();

return $this->prepare_pdu(GET_REQUEST,
                             $this->_create_oid_null_pairs($oids));
}

sub prepare_get_next_request
{
   my ($this, $oids) = @_;

$this->_error_clear();

return $this->prepare_pdu(GET_NEXT_REQUEST,
                             $this->_create_oid_null_pairs($oids));
}

sub prepare_get_response
{
   my ($this, $trios) = @_;

$this->_error_clear();

return $this->prepare_pdu(GET_RESPONSE,
                             $this->_create_oid_value_pairs($trios));
}

sub prepare_set_request
{
   my ($this, $trios) = @_;

$this->_error_clear();

return $this->prepare_pdu(SET_REQUEST,
                             $this->_create_oid_value_pairs($trios));
}

sub prepare_trap
{
   my ($this, $enterprise, $addr, $generic, $specific, $time, $trios) = @_;

$this->_error_clear();

return $this->_error('Insufficient arguments for a Trap-PDU') if (@_ < 6);

# enterprise

if (!defined $enterprise) {

# Use iso(1).org(3).dod(6).internet(1).private(4).enterprises(1) 
      # for the default enterprise.

$this->{_enterprise} = '1.3.6.1.4.1';

} elsif ($enterprise !~ m/^\.?\d+(?:\.\d+)* *$/) {
      return $this->_error(
         'The enterprise OBJECT IDENTIFIER "%s" is expected in dotted ' .
         'decimal notation', $enterprise
      );
   } else {
      $this->{_enterprise} = $enterprise;
   }

# agent-addr

if (!defined $addr) {

# See if we can get the agent-addr from the Transport
      # Layer.  If not, we return an error.

if (defined $this->{_transport}) {
         if (($this->{_transport}->domain() ne DOMAIN_UDPIPV4) &&
             ($this->{_transport}->domain() ne DOMAIN_TCPIPV4))
         {
            $this->{_agent_addr} = '0.0.0.0';
         } else {
            $this->{_agent_addr} = $this->{_transport}->agent_addr();
            if ($this->{_agent_addr} eq '0.0.0.0') {
               delete $this->{_agent_addr};
            }
         }
      }
      if (!exists $this->{_agent_addr}) {
         return $this->_error('Unable to resolve the local agent-addr');
      }

} elsif ($addr !~ /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/) {
      return $this->_error(
         'The agent-addr "%s" is expected in dotted decimal notation', $addr
      );
   } else {
      $this->{_agent_addr} = $addr;
   }

# generic-trap

if (!defined $generic) {

# Use enterpriseSpecific(6) for the generic-trap type.
      $this->{_generic_trap} = ENTERPRISE_SPECIFIC;

} elsif ($generic !~ /^\d+$/) {
      return $this->_error(
         'The generic-trap value "%s" is expected in positive numeric format',
         $generic
      );
   } else {
      $this->{_generic_trap} = $generic;
   }

# specific-trap

if (!defined $specific) {
      $this->{_specific_trap} = 0;
   } elsif ($specific !~ /^\d+$/) {
      return $this->_error(
         'The specific-trap value "%s" is expected in positive numeric format',
         $specific
      );
   } else {
      $this->{_specific_trap} = $specific;
   }

# time-stamp

if (!defined $time) {

# Use the "uptime" of the script for the time-stamp.
      $this->{_time_stamp} = ((time() - $^T) * 100);

} elsif ($time !~ /^\d+$/) {
      return $this->_error(
         'The time-stamp value "%s" is expected in positive numeric format',
         $time
      );
   } else {
      $this->{_time_stamp} = $time;
   }

return $this->prepare_pdu(TRAP, $this->_create_oid_value_pairs($trios));
}

sub prepare_get_bulk_request
{
   my ($this, $repeaters, $repetitions, $oids) = @_;

$this->_error_clear();

if (@_ < 3) {
      return $this->_error('Insufficient arguments for a GetBulkRequest-PDU');
   }

# non-repeaters

if (!defined $repeaters) {
      $this->{_error_status} = 0;
   } elsif ($repeaters !~ /^\d+$/) {
      return $this->_error(
         'The non-repeaters value "%s" is expected in positive numeric format',
         $repeaters
      );
   } elsif ($repeaters > 2147483647) {
      return $this->_error(
         'The non-repeaters value %s is out of range (0..2147483647)',
         $repeaters
      );
   } else {
      $this->{_error_status} = $repeaters;
   }

# max-repetitions

if (!defined $repetitions) {
      $this->{_error_index} = 0;
   } elsif ($repetitions !~ /^\d+$/) {
      return $this->_error(
         'The max-repetitions value "%s" is expected in positive numeric ' .
         'format', $repetitions
      );
   } elsif ($repetitions > 2147483647) {
      return $this->_error(
         'The max-repetitions value %s is out of range (0..2147483647)',
         $repetitions
      );
   } else {
      $this->{_error_index} = $repetitions;
   }

# Some sanity checks

if (defined($oids) && (ref($oids) eq 'ARRAY')) {

if ($this->{_error_status} > @{$oids}) {
         return $this->_error(
            'The non-repeaters value %d is greater than the number of ' .
            'variable-bindings %d', $this->{_error_status}, scalar @{$oids}
         );
      }

if (($this->{_error_status} == @{$oids}) && ($this->{_error_index})) {
         return $this->_error(
            'The non-repeaters value %d equals the number of variable-' .
            'bindings and max-repetitions is not equal to zero',
             $this->{_error_status}
         );
      }
   }

return $this->prepare_pdu(GET_BULK_REQUEST,
                             $this->_create_oid_null_pairs($oids));
}

sub prepare_inform_request
{
   my ($this, $trios) = @_;

$this->_error_clear();

return $this->prepare_pdu(INFORM_REQUEST,
                             $this->_create_oid_value_pairs($trios));
}

sub prepare_snmpv2_trap
{
   my ($this, $trios) = @_;

$this->_error_clear();

return $this->prepare_pdu(SNMPV2_TRAP,
                             $this->_create_oid_value_pairs($trios));
}

sub prepare_report
{
   my ($this, $trios) = @_;

$this->_error_clear();

return $this->prepare_pdu(REPORT, $this->_create_oid_value_pairs($trios));
}

sub prepare_pdu
{
   my ($this, $type, $var_bind) = @_;

# Clear the buffer
   $this->clear();

# Clear the "scoped" indication
   $this->{_scoped} = FALSE;

# VarBindList::=SEQUENCE OF VarBind
   if (!defined $this->_prepare_var_bind_list($var_bind || [])) {
      return $this->_error();
   }

# PDU::=SEQUENCE 
   if (!defined $this->_prepare_pdu_sequence($type)) {
      return $this->_error();
   }

return TRUE;
}

sub prepare_var_bind_list
{
   my ($this, $var_bind) = @_;

return $this->_prepare_var_bind_list($var_bind || []);
}

sub prepare_pdu_sequence
{
   goto &_prepare_pdu_sequence;
}

sub prepare_pdu_scope
{
   goto &_prepare_pdu_scope;
}

sub process_pdu
{
   my ($this) = @_;

# Clear any errors 
   $this->_error_clear();

# PDU::=SEQUENCE
   return $this->_error() if !defined $this->_process_pdu_sequence();

# VarBindList::=SEQUENCE OF VarBind
   return $this->_process_var_bind_list();
}

sub process_pdu_scope
{
   goto &_process_pdu_scope;
}

sub process_pdu_sequence
{
   goto &_process_pdu_sequence;
}

sub process_var_bind_list
{
   goto &_process_var_bind_list;
}

sub expect_response
{
   my ($this) = @_;

if (($this->{_pdu_type} == GET_RESPONSE) ||
       ($this->{_pdu_type} == TRAP)         ||
       ($this->{_pdu_type} == SNMPV2_TRAP)  ||
       ($this->{_pdu_type} == REPORT))
   {
      return FALSE;
   }

return TRUE;
}

sub pdu_type
{
   return $_[0]->{_pdu_type};
}

sub error_status
{
   my ($this, $status) = @_;

# error-status::=INTEGER { noError(0) .. inconsistentName(18) }

if (@_ == 2) {
      if (!defined $status) {
         return $this->_error('The error-status value is not defined');
      }
      if (($status < 0) ||
          ($status > (($this->version > SNMP_VERSION_1) ? 18 : 5)))
      {
         return $this->_error(
            'The error-status %s is out of range (0..%d)',
            $status, ($this->version > SNMP_VERSION_1) ? 18 : 5
         );
      }
      $this->{_error_status} = $status;
   }

return $this->{_error_status} || 0; # noError(0)
}

sub error_index
{
   my ($this, $index) = @_;

# error-index::=INTEGER (0..max-bindings)

if (@_ == 2) {
      if (!defined $index) {
         return $this->_error('The error-index value is not defined');
      }
      if (($index < 0) || ($index > 2147483647)) {
         return $this->_error(
            'The error-index value %s is out of range (0.. 2147483647)',
            $index
         );
      }
      $this->{_error_index} = $index;
   }

return $this->{_error_index} || 0;
}

sub non_repeaters
{
   # non-repeaters::=INTEGER (0..max-bindings)

return $_[0]->{_error_status} || 0;
}

sub max_repetitions
{
   # max-repetitions::=INTEGER (0..max-bindings)

return $_[0]->{_error_index} || 0;
}

sub enterprise
{
   return $_[0]->{_enterprise};
}

sub agent_addr
{
   return $_[0]->{_agent_addr};
}

sub generic_trap
{
   return $_[0]->{_generic_trap};
}

sub specific_trap
{
   return $_[0]->{_specific_trap};
}

sub time_stamp
{
   return $_[0]->{_time_stamp};
}

sub var_bind_list
{
   my ($this, $vbl, $types) = @_;

return if defined $this->{_error};

if (@_ > 1) {

# The VarBindList HASH is being updated from an external
      # source.  We need to update the VarBind names ARRAY to
      # correspond to the new keys of the HASH.  If the updated
      # information is valid, we will use lexicographical ordering
      # for the ARRAY entries since we do not have a PDU to use
      # to determine the ordering.  The ASN.1 types HASH is also
      # updated here if a cooresponding HASH is passed.  We double
      # check the mapping by populating the hash with the keys of
      # the VarBindList HASH.

if (!defined($vbl) || (ref($vbl) ne 'HASH')) {

$this->{_var_bind_list}  = undef;
         $this->{_var_bind_names} = [];
         $this->{_var_bind_types} = undef;

} else {

$this->{_var_bind_list} = $vbl;

@{$this->{_var_bind_names}} =
            map  { $_->[0] }
               sort { $a->[1] cmp $b->[1] }
                  map
                  {
                     my $oid = $_;
                     $oid =~ s/^\.//;
                     $oid =~ s/ /\.0/g;
                     [$_, pack 'N*', split m/\./, $oid]
                  } keys %{$vbl};

if (!defined($types) || (ref($types) ne 'HASH')) {
             $types = {};
         }

for (keys %{$vbl}) {
            $this->{_var_bind_types}->{$_} =
               exists($types->{$_}) ? $types->{$_} : undef;
         }

}

return $this->{_var_bind_list};
}

sub var_bind_names
{
   my ($this) = @_;

return [] if defined($this->{_error}) || !defined $this->{_var_bind_names};

return $this->{_var_bind_names};
}

sub var_bind_types
{
   my ($this) = @_;

return if defined $this->{_error};

return $this->{_var_bind_types};
}

sub scoped
{
   return $_[0]->{_scoped};
}

# [private methods] ----------------------------------------------------------

sub _prepare_pdu_scope
{
   my ($this) = @_;

return TRUE if (($this->{_version} < SNMP_VERSION_3) || ($this->{_scoped}));

# contextName::=OCTET STRING
   if (!defined $this->prepare(OCTET_STRING, $this->context_name())) {
      return $this->_error();
   }

# contextEngineID::=OCTET STRING
   if (!defined $this->prepare(OCTET_STRING, $this->context_engine_id())) {
      return $this->_error();
   }

# ScopedPDU::=SEQUENCE
   if (!defined $this->prepare(SEQUENCE)) {
       return $this->_error();
   }

# Indicate that this PDU has been scoped and return success.
   return $this->{_scoped} = TRUE;
}

sub _prepare_pdu_sequence
{
   my ($this, $type) = @_;

# Do not do anything if there has already been an error
   return $this->_error() if defined $this->{_error};

# Make sure the PDU type was passed
   return $this->_error('The SNMP PDU type is not defined') if (@_ != 2);

# Set the PDU type
   $this->{_pdu_type} = $type;

# Make sure the request-id has been set
   if (!exists $this->{_request_id}) {
      $this->{_request_id} = int rand 2147483648;
   }

# We need to encode everything in reverse order so the
   # objects end up in the correct place.

if ($this->{_pdu_type} != TRAP) { # PDU::=SEQUENCE

# error-index/max-repetitions::=INTEGER 
      if (!defined $this->prepare(INTEGER, $this->{_error_index})) {
         return $this->_error();
      }

# error-status/non-repeaters::=INTEGER
      if (!defined $this->prepare(INTEGER, $this->{_error_status})) {
         return $this->_error();
      }

# request-id::=INTEGER  
      if (!defined $this->prepare(INTEGER, $this->{_request_id})) {
         return $this->_error();
      }

} else { # Trap-PDU::=IMPLICIT SEQUENCE

# time-stamp::=TimeTicks 
      if (!defined $this->prepare(TIMETICKS, $this->{_time_stamp})) {
         return $this->_error();
      }

# specific-trap::=INTEGER 
      if (!defined $this->prepare(INTEGER, $this->{_specific_trap})) {
         return $this->_error();
      }

# generic-trap::=INTEGER  
      if (!defined $this->prepare(INTEGER, $this->{_generic_trap})) {
         return $this->_error();
      }

# agent-addr::=NetworkAddress 
      if (!defined $this->prepare(IPADDRESS, $this->{_agent_addr})) {
         return $this->_error();
      }

# enterprise::=OBJECT IDENTIFIER 
      if (!defined $this->prepare(OBJECT_IDENTIFIER, $this->{_enterprise})) {
         return $this->_error();
      }

}

# PDUs::=CHOICE 
   if (!defined $this->prepare($this->{_pdu_type})) {
      return $this->_error();
   }

return TRUE;
}

sub _prepare_var_bind_list
{
   my ($this, $var_bind) = @_;

# The passed array is expected to consist of groups of four values
   # consisting of two sets of ASN.1 types and their values.

if (@{$var_bind} % 4) {
      $this->var_bind_list(undef);
      return $this->_error(
         'The VarBind list size of %d is not a factor of 4', scalar @{$var_bind}
      );
   }

# Initialize the "var_bind_*" data.

$this->{_var_bind_list}  = {};
   $this->{_var_bind_names} = [];
   $this->{_var_bind_types} = {};

# Use the object's buffer to build each VarBind SEQUENCE and then append
   # it to a local buffer.  The local buffer will then be used to create 
   # the VarBindList SEQUENCE.

my ($buffer, $name_type, $name_value, $syntax_type, $syntax_value) = (q{});

while (@{$var_bind}) {

# Pull a quartet of ASN.1 types and values from the passed array.
      ($name_type, $name_value, $syntax_type, $syntax_value) =
         splice @{$var_bind}, 0, 4;

# Reverse the order of the fields because prepare() does a prepend.

# value::=ObjectSyntax
      if (!defined $this->prepare($syntax_type, $syntax_value)) {
         $this->var_bind_list(undef);
         return $this->_error();
      }

# name::=ObjectName
      if ($name_type != OBJECT_IDENTIFIER) {
         $this->var_bind_list(undef);
         return $this->_error(
            'An ObjectName type of 0x%02x was expected, but 0x%02x was found',
            OBJECT_IDENTIFIER, $name_type
         );
      }
      if (!defined $this->prepare($name_type, $name_value)) {
         $this->var_bind_list(undef);
         return $this->_error();
      }

# VarBind::=SEQUENCE
      if (!defined $this->prepare(SEQUENCE)) {
         $this->var_bind_list(undef);
         return $this->_error();
      }

# Append the VarBind to the local buffer and clear it.
      $buffer .= $this->clear();

# Populate the "var_bind_*" data so we can provide consistent
      # output for the methods regardless of whether we are a request 
      # or a response PDU.  Make sure the HASH key is unique if in 
      # case duplicate OBJECT IDENTIFIERs are provided.

while (exists $this->{_var_bind_list}->{$name_value}) {
         $name_value .= q{ }; # Pad with spaces
      }

$this->{_var_bind_list}->{$name_value}  = $syntax_value;
      $this->{_var_bind_types}->{$name_value} = $syntax_type;
      push @{$this->{_var_bind_names}}, $name_value;

}

# VarBindList::=SEQUENCE OF VarBind
   if (!defined $this->prepare(SEQUENCE, $buffer)) {
      $this->var_bind_list(undef);
      return $this->_error();
   }

return TRUE;
}

sub _create_oid_null_pairs
{
   my ($this, $oids) = @_;

return [] if !defined $oids;

if (ref($oids) ne 'ARRAY') {
      return $this->_error(
         'The OBJECT IDENTIFIER list is expected as an array reference'
      );
   }

my $pairs = [];

for (@{$oids}) {
      push @{$pairs}, OBJECT_IDENTIFIER, $_, NULL, q{};
   }

return $pairs;
}

sub _create_oid_value_pairs
{
   my ($this, $trios) = @_;

return [] if !defined $trios;

if (ref($trios) ne 'ARRAY') {
      return $this->_error('The trio list is expected as an array reference');
   }

if (@{$trios} % 3) {
      return $this->_error(
         'The [OBJECT IDENTIFIER, ASN.1 type, object value] trio is expected'
      );
   }

my $pairs = [];

for (my $i = 0; $i < $#{$trios}; $i += 3) {
      push @{$pairs},
         OBJECT_IDENTIFIER, $trios->[$i], $trios->[$i+1], $trios->[$i+2];
   }

return $pairs;
}

sub _process_pdu_scope
{
   my ($this) = @_;

return TRUE if ($this->{_version} < SNMP_VERSION_3);

# ScopedPDU::=SEQUENCE
   return $this->_error() if !defined $this->process(SEQUENCE);

# contextEngineID::=OCTET STRING
   if (!defined $this->context_engine_id($this->process(OCTET_STRING))) {
      return $this->_error();
   }

# contextName::=OCTET STRING
   if (!defined $this->context_name($this->process(OCTET_STRING))) {
      return $this->_error();
   }

# Indicate that this PDU is scoped and return success.
   return $this->{_scoped} = TRUE;
}

sub _process_pdu_sequence
{
   my ($this) = @_;

# PDUs::=CHOICE
   if (!defined ($this->{_pdu_type} = $this->process())) {
      return $this->_error();
   }

if ($this->{_pdu_type} != TRAP) { # PDU::=SEQUENCE

# request-id::=INTEGER
      if (!defined ($this->{_request_id} = $this->process(INTEGER))) {
         return $this->_error();
      }
      # error-status::=INTEGER
      if (!defined ($this->{_error_status} = $this->process(INTEGER))) {
         return $this->_error();
      }
      # error-index::=INTEGER
      if (!defined ($this->{_error_index} = $this->process(INTEGER))) {
         return $this->_error();
      }

# Indicate that we have an SNMP error, but do not return an error.
      if (($this->{_error_status}) && ($this->{_pdu_type} == GET_RESPONSE)) {
         $this->_error(
            'Received %s error-status at error-index %d',
            _error_status_itoa($this->{_error_status}), $this->{_error_index}
         );
      }

} else { # Trap-PDU::=IMPLICIT SEQUENCE

# enterprise::=OBJECT IDENTIFIER
      if (!defined ($this->{_enterprise} = $this->process(OBJECT_IDENTIFIER))) {
         return $this->_error();
      }
      # agent-addr::=NetworkAddress
      if (!defined ($this->{_agent_addr} = $this->process(IPADDRESS))) {
         return $this->_error();
      }
      # generic-trap::=INTEGER
      if (!defined ($this->{_generic_trap} = $this->process(INTEGER))) {
         return $this->_error();
      }
      # specific-trap::=INTEGER
      if (!defined ($this->{_specific_trap} = $this->process(INTEGER))) {
         return $this->_error();
      }
      # time-stamp::=TimeTicks
      if (!defined ($this->{_time_stamp} = $this->process(TIMETICKS))) {
         return $this->_error();
      }

}

return TRUE;
}

sub _process_var_bind_list
{
   my ($this) = @_;

my $value;

# VarBindList::=SEQUENCE
   if (!defined($value = $this->process(SEQUENCE))) {
      return $this->_error();
   }

# Using the length of the VarBindList SEQUENCE, 
   # calculate the end index.

my $end = $this->index() + $value;

$this->{_var_bind_list}  = {};
   $this->{_var_bind_names} = [];
   $this->{_var_bind_types} = {};

my ($oid, $type);

while ($this->index() < $end) {

# VarBind::=SEQUENCE
      if (!defined $this->process(SEQUENCE)) {
         return $this->_error();
      }
      # name::=ObjectName
      if (!defined ($oid = $this->process(OBJECT_IDENTIFIER))) {
         return $this->_error();
      }
      # value::=ObjectSyntax
      if (!defined ($value = $this->process(undef, $type))) {
         return $this->_error();
      }

# Create a hash consisting of the OBJECT IDENTIFIER as a
      # key and the ObjectSyntax as the value.  If there is a
      # duplicate OBJECT IDENTIFIER in the VarBindList, we pad
      # that OBJECT IDENTIFIER with spaces to make a unique
      # key in the hash.

while (exists $this->{_var_bind_list}->{$oid}) {
         $oid .= q{ }; # Pad with spaces
      }

DEBUG_INFO('{ %s => %s: %s }', $oid, asn1_itoa($type), $value);
      $this->{_var_bind_list}->{$oid}  = $value;
      $this->{_var_bind_types}->{$oid} = $type;

# Create an array with the ObjectName OBJECT IDENTIFIERs
      # so that the order in which the VarBinds where encoded
      # in the PDU can be retrieved later.

push @{$this->{_var_bind_names}}, $oid;

}

# Return an error based on the contents of the VarBindList
   # if we received a Report-PDU.

if ($this->{_pdu_type} == REPORT) {
      return $this->_report_pdu_error();
   }

# Return the var_bind_list hash
   return $this->{_var_bind_list};
}

{
   my @error_status = qw(
      noError
      tooBig
      noSuchName
      badValue
      readOnly
      genError
      noAccess
      wrongType
      wrongLength
      wrongEncoding
      wrongValue
      noCreation
      inconsistentValue
      resourceUnavailable
      commitFailed
      undoFailed
      authorizationError
      notWritable
      inconsistentName
   );

sub _error_status_itoa
   {
      return '??' if (@_ != 1);

if (($_[0] > $#error_status) || ($_[0] < 0)) {
         return sprintf '??(%d)', $_[0];
      }

return sprintf '%s(%d)', $error_status[$_[0]], $_[0];
   }
}

{
   my %report_oids = (
      '1.3.6.1.6.3.11.2.1.1' => 'snmpUnknownSecurityModels',
      '1.3.6.1.6.3.11.2.1.2' => 'snmpInvalidMsgs',
      '1.3.6.1.6.3.11.2.1.3' => 'snmpUnknownPDUHandlers',
      '1.3.6.1.6.3.12.1.4'   => 'snmpUnavailableContexts',
      '1.3.6.1.6.3.12.1.5'   => 'snmpUnknownContexts',
      '1.3.6.1.6.3.15.1.1.1' => 'usmStatsUnsupportedSecLevels',
      '1.3.6.1.6.3.15.1.1.2' => 'usmStatsNotInTimeWindows',
      '1.3.6.1.6.3.15.1.1.3' => 'usmStatsUnknownUserNames',
      '1.3.6.1.6.3.15.1.1.4' => 'usmStatsUnknownEngineIDs',
      '1.3.6.1.6.3.15.1.1.5' => 'usmStatsWrongDigests',
      '1.3.6.1.6.3.15.1.1.6' => 'usmStatsDecryptionErrors',
   );

sub _report_pdu_error
   {
      my ($this) = @_;

# Remove the leading dot (if present) and replace the dotted notation
      # of the OBJECT IDENTIFIER with the text ObjectName based upon an
      # expected list of report OBJECT IDENTIFIERs.

my %var_bind_list;

for my $oid (@{$this->{_var_bind_names}}) {
         my $text = $oid;
         $text =~ s/^\.//;
         for (keys %report_oids) {
            if ($text =~ s/\Q$_/$report_oids{$_}/) {
               last;
            }
         }
         $var_bind_list{$text} = $this->{_var_bind_list}->{$oid};
      }

my $count = keys %var_bind_list;

if ($count == 1) {
         # Return the OBJECT IDENTIFIER and value.
         my $text = (keys %var_bind_list)[0];
         return $this->_error(
            'Received %s Report-PDU with value %s', $text, $var_bind_list{$text}
         );
      } elsif ($count > 1) {
         # Return a list of OBJECT IDENTIFIERs.
         return $this->_error(
            'Received Report-PDU [%s]', join ', ', keys %var_bind_list
         );
      } else {
         return $this->_error('Received empty Report-PDU');
      }

}
}

# ============================================================================
1; # [end Net::SNMP::PDU]