view release on metacpan or  search on metacpan

lib/Net/Frame/Layer/SNMP.pm  view on Meta::CPAN

sub match {
   my $self = shift;
   my ($with) = @_;
   my $sPduType = $self->pdu_type;
   my $sReqId   = $self->requestId;
   my $wPduType = $with->pdu_type;
   my $wReqId   = $with->requestId;
   if ((($sPduType == NF_SNMP_PDUTYPE_GET) 
     || ($sPduType == NF_SNMP_PDUTYPE_GETNEXT) 
     || ($sPduType == NF_SNMP_PDUTYPE_SET) 
     || ($sPduType == NF_SNMP_PDUTYPE_GETBULK) 
     || ($sPduType == NF_SNMP_PDUTYPE_INFORM))

     && ($wPduType == NF_SNMP_PDUTYPE_RESPONSE)
     && ($sReqId == $wReqId)) {
      return 1;
   }
   0;
}

# XXX: may be better, by keying on type also
sub getKey        { shift->layer }
sub getKeyReverse { shift->layer }

sub getLength {    
   my $self = shift;

   return length($self->pack)
}

sub pack {
   my $self = shift;

   my $raw;
   if (($self->pdu_type == NF_SNMP_PDUTYPE_GET)
   ||  ($self->pdu_type == NF_SNMP_PDUTYPE_GETNEXT)
   ||  ($self->pdu_type == NF_SNMP_PDUTYPE_RESPONSE)
   ||  ($self->pdu_type == NF_SNMP_PDUTYPE_SET)
   ||  ($self->pdu_type == NF_SNMP_PDUTYPE_INFORM)
   ||  ($self->pdu_type == NF_SNMP_PDUTYPE_V2TRAP)
   ||  ($self->pdu_type == NF_SNMP_PDUTYPE_REPORT)) {
      $raw = $snmpasn->encode(
         version   => $self->version,
         community => $self->community,
         pdu_type  => {
            $PDUTYPES[$self->pdu_type] => {
               requestId   => $self->requestId,
               errorStatus => $self->errorStatus,
               errorIndex  => $self->errorIndex,
               varbindlist => [$self->varbindlist]
            }
         }
      );
      if (defined($snmpasn->error)) {
         print $snmpasn->error;
         return
      }
   } elsif ($self->pdu_type == NF_SNMP_PDUTYPE_TRAP) {
      my $agent_addr;
      if ($self->agentAddr =~ /:/) {
         $agent_addr = inet6Aton($self->agentAddr)
      } else {
         $agent_addr = inetAton($self->agentAddr)
      }
      $raw = $snmpasn->encode(
         version   => $self->version,
         community => $self->community,
         pdu_type  => {
            $PDUTYPES[$self->pdu_type] => {
               entOid       => $self->entOid,
               agentAddr    => $agent_addr,
               genericTrap  => $self->genericTrap,
               specificTrap => $self->specificTrap,
               timeticks    => $self->timeticks,
               varbindlist  => [$self->varbindlist]
            }
         }
      );
      if (defined($snmpasn->error)) {
         print $snmpasn->error;
         return
      }
   } elsif ($self->pdu_type == NF_SNMP_PDUTYPE_GETBULK) {
      $raw = $snmpasn->encode(
         version   => $self->version,
         community => $self->community,
         pdu_type  => {
            $PDUTYPES[$self->pdu_type] => {
               requestId      => $self->requestId,
               nonRepeaters   => $self->nonRepeaters,
               maxRepetitions => $self->maxRepetitions,
               varbindlist    => [$self->varbindlist]
            }
         }
      );
      if (defined($snmpasn->error)) {
         print $snmpasn->error;
         return
      }
   }

   return $self->raw($raw);
}

sub unpack {
   my $self = shift;

   my $pdu = $snmpasn->decode($self->raw);
   if (defined($snmpasn->error)) {
      print $snmpasn->error;
      return
   }

   $self->version($pdu->{version});
   $self->community($pdu->{community});
   my $pdutype = sprintf "%s", keys(%{$pdu->{pdu_type}});
   $self->pdu_type($PDUTYPES{$pdutype});
   if (($self->pdu_type == NF_SNMP_PDUTYPE_GET)
   ||  ($self->pdu_type == NF_SNMP_PDUTYPE_GETNEXT)
   ||  ($self->pdu_type == NF_SNMP_PDUTYPE_RESPONSE)
   ||  ($self->pdu_type == NF_SNMP_PDUTYPE_SET)

lib/Net/Frame/Layer/SNMP.pm  view on Meta::CPAN

   if ($params{'type'} eq 'null') {
      $params{'value'} = 1
   }

   my %hash = (
      oid   => $params{'oid'},
      value => {
         $params{'type'} => $params{'value'}
      }
   );

   return \%hash;
}

sub v2trap_varbinds {
   my $self = shift;

   my %params = (
      oid       => '1.3.6.1.4.1.50000',
      timeticks => time(),
   );
   if (@_ == 1) {
      return(undef)
   } else {
      my %cfg = @_;
      for (keys(%cfg)) {
         if (/^-?oid$/i) {
            $params{'oid'} = $cfg{$_}
         } elsif (/^-?time(?:ticks)?$/i) {
            $params{'timeticks'} = $cfg{$_}
         }
      }
   }

   my %hash1 = (
      oid   => '1.3.6.1.2.1.1.3.0',
      value => {
         timeticks => $params{'timeticks'}
      }
   );

   my %hash2 = (
      oid   => '1.3.6.1.6.3.1.1.4.1.0',
      value => {
         oid => $params{'oid'}
      }
   );

   my @varbinds;
   push @varbinds, \%hash1;
   push @varbinds, \%hash2;

   return @varbinds;
}

sub _inetNtoa {
    my ($addr) = @_;
    if (length($addr) == 4) {
        return inet_ntoa($addr)
    } else {
        return inet6Ntoa($addr)
    }
}

1;

__END__

=head1 NAME

Net::Frame::Layer::SNMP - Simple Network Management Protocol layer object

=head1 SYNOPSIS

   use Net::Frame::Simple;
   use Net::Frame::Layer::SNMP qw(:consts);

   my $snmp = Net::Frame::Layer::SNMP->new(
      version     => NF_SNMP_VERSION_2,
      community   => 'public',
      requestId   => getRandom16bitsInt(),
      errorStatus => 0,
      errorIndex  => 0,
      varbindlist => [],
   );

   #
   # Read a raw layer
   #

   my $layer = Net::Frame::Layer::SNMP->new(raw => $raw);

   print $layer->print."\n";
   print 'PAYLOAD: '.unpack('H*', $layer->payload)."\n"
      if $layer->payload;

=head1 DESCRIPTION

This modules implements the encoding and decoding of the SNMP layer.

See also B<Net::Frame::Layer> for other attributes and methods.

=head1 ATTRIBUTES

=over 4

=item B<version>

SNMP version.  This module supports version 1 and version 2(c).

=item B<community>

SNMP community string.

=item B<requestId>

=item B<errorStatus>

=item B<errorIndex>

SNMP fields for Get, GetNext, Response, Set, Inform, V2Trap and Report PDU types.