File Coverage

blib/lib/Net/Frame/Layer/VRRP.pm

Criterion	Covered	Total	%
statement	88	120	73.3
branch	5	26	19.2
condition	1	9	11.1
subroutine	20	23	86.9
pod	8	8	100.0
total	122	186	65.5

#
# $Id: VRRP.pm 49 2009-05-31 13:15:34Z VinsWorldcom $
#
package Net::Frame::Layer::VRRP;
use strict; use warnings;

our $VERSION = '1.00';

use Net::Frame::Layer qw(:consts :subs);
use Exporter;
our @ISA = qw(Net::Frame::Layer Exporter);

our %EXPORT_TAGS = (
   consts => [qw(
      NF_VRRP_ALLVRRPRTRS
      NF_VRRP_ALLVRRPRTRS_MAC
      NF_VRRP_VERSION
      NF_VRRP_TYPE_ADVERT
      NF_VRRP_PRIORITY_OWNER
      NF_VRRP_PRIORITY_DEFAULT
      NF_VRRP_PRIORITY_NOMASTER
      NF_VRRP_AUTH_NO
      NF_VRRP_AUTH_TEXT
      NF_VRRP_AUTH_AH
   )],
);
our @EXPORT_OK = (
   @{$EXPORT_TAGS{consts}},
);

use constant NF_VRRP_ALLVRRPRTRS     => '224.0.0.18';
use constant NF_VRRP_ALLVRRPRTRS_MAC => '01:00:5e:00:00:12';
use constant NF_VRRP_VERSION         => 2;
use constant NF_VRRP_TYPE_ADVERT     => 1;
use constant NF_VRRP_PRIORITY_OWNER    => 255;
use constant NF_VRRP_PRIORITY_DEFAULT  => 100;
use constant NF_VRRP_PRIORITY_NOMASTER => 0;
use constant NF_VRRP_AUTH_NO         => 0;
use constant NF_VRRP_AUTH_TEXT       => 1;
use constant NF_VRRP_AUTH_AH         => 2;

our @AS = qw(
   version
   type
   vrId
   priority
   countIp
   authType
   interval
   checksum
   authentication
);
our @AA = qw(
   ipAddresses
);
__PACKAGE__->cgBuildIndices;
__PACKAGE__->cgBuildAccessorsScalar(\@AS);
__PACKAGE__->cgBuildAccessorsArray(\@AA);

#no strict 'vars';

use Bit::Vector;

sub new {
   shift->SUPER::new(
      version     => NF_VRRP_VERSION,
      type        => NF_VRRP_TYPE_ADVERT,
      vrId        => 1,
      priority    => NF_VRRP_PRIORITY_DEFAULT,
      countIp     => 1,
      authType    => NF_VRRP_AUTH_NO,
      interval    => 1,
      checksum    => 0,
      ipAddresses => ['127.0.0.1'],
      authentication => '',
      @_,
   );
}

sub getLength {
   my $self = shift;
   my $len = 16;
   $len += 4 for $self->ipAddresses;
   return $len;
}

sub pack {
   my $self = shift;

   my $version = Bit::Vector->new_Dec(4, $self->version);
   my $type    = Bit::Vector->new_Dec(4, $self->type);
   my $bvlist  = $version->Concat_List($type);

   my $raw = $self->SUPER::pack('CCCCCCn',
      $bvlist->to_Dec,
      $self->vrId,
      $self->priority,
      $self->countIp,
      $self->authType,
      $self->interval,
      $self->checksum,
   ) or return;

   for ($self->ipAddresses) {
      $raw .= inetAton($_);
   }

   $raw .= $self->SUPER::pack('a8',
       $self->authentication,
   ) or return;

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

sub unpack {
   my $self = shift;

   my ($bv, $vrId, $priority, $countIp, $authType,
       $interval, $checksum, $payload) =
      $self->SUPER::unpack('CCCCCCn a*', $self->raw)
         or return;

   my $bvlist = Bit::Vector->new_Dec(8, $bv);
   $self->version ($bvlist->Chunk_Read(4, 4));
   $self->type    ($bvlist->Chunk_Read(4, 0));

   $self->vrId($vrId);
   $self->priority($priority);
   $self->countIp($countIp);
   $self->authType($authType);
   $self->interval($interval);
   $self->checksum($checksum);

   my @ipAddresses = ();
   for my $num (0..$countIp-1) {
      if (defined($payload) && (length($payload) >= 4)) {
         my $addr = unpack 'a4', $payload;
         push @ipAddresses, inetNtoa($addr);
         $payload = substr $payload, 4;
      }
   }
   $self->ipAddresses(\@ipAddresses);

   my $authentication = unpack 'a8', $payload;
   $payload = substr $payload, 8;

   $self->authentication($authentication);

   $self->payload($payload);

   return $self;
}

sub computeChecksums {
   my $self = shift;
   my ($layers) = @_;

   my $version = Bit::Vector->new_Dec(4, $self->version);
   my $type    = Bit::Vector->new_Dec(4, $self->type);
   my $bvlist  = $version->Concat_List($type);

   my $phpkt = $self->SUPER::pack('CCCCCCn',
      $bvlist->to_Dec,
      $self->vrId,
      $self->priority,
      $self->countIp,
      $self->authType,
      $self->interval,
      0,
   ) or return;

   for ($self->ipAddresses) {
      $phpkt .= inetAton($_);
   }

   $phpkt .= $self->SUPER::pack('a8',
       $self->authentication,
   ) or return;

   my $start   = 0;
   my $last    = $self;
   my $payload = '';
   for my $l (@$layers) {
      $last = $l;
      if (! $start) {
	 $start++ if $l->layer eq 'VRRP';
         next;
      }
      $payload .= $l->pack;
   }

   if (defined($last->payload) && length($last->payload)) {
      $payload .= $last->payload;
   }

   if (length($payload)) {
      $phpkt .= $self->SUPER::pack('a*', $payload)
         or return;
   }

   $self->checksum(inetChecksum($phpkt));

   return 1;
}

sub encapsulate {
   my $self = shift;

   return $self->nextLayer if $self->nextLayer;

   NF_LAYER_NONE;
}

sub computeLengths {
   my $self = shift;

   # Calculate countIp from ipAddresses array items
   if (scalar($self->ipAddresses) && ($self->countIp == 0)) {
      $self->countIp(scalar($self->ipAddresses))
   }

   return 1;
}

sub print {
   my $self = shift;

   my $l = $self->layer;
   my $buf = sprintf
      "$l: version:%d  type:%d  vrId:%d  priority:%d\n".
      "$l: countIp:%d  authType:%d  interval:%d  checksum:0x%04x",
         $self->version, $self->type, $self->vrId, $self->priority,
         $self->countIp, $self->authType, $self->interval, $self->checksum;

   for ($self->ipAddresses) {
      $buf .= sprintf
      "\n$l: ipAddresses:%s",
         $_
   }

   $buf .= sprintf
      "\n$l: authentication:%s",
         $self->authentication;

   return $buf;
}

1;

__END__