File Coverage

blib/lib/Net/Frame/Layer/CDP/ManagementAddresses.pm

Criterion	Covered	Total	%
statement	39	55	70.9
branch	3	8	37.5
condition	1	6	16.6
subroutine	9	11	81.8
pod	6	6	100.0
total	58	86	67.4

#
# $Id: ManagementAddresses.pm 1640 2013-03-28 17:58:27Z VinsWorldcom $
#
package Net::Frame::Layer::CDP::ManagementAddresses;
use strict; use warnings;

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

our @AS = qw(
   type
   length
   numAddresses
);
our @AA = qw(
   addresses
);
__PACKAGE__->cgBuildIndices;
__PACKAGE__->cgBuildAccessorsScalar(\@AS);
__PACKAGE__->cgBuildAccessorsArray (\@AA);

#no strict 'vars';

use Net::Frame::Layer::CDP::Constants qw(:consts);

sub new {
   shift->SUPER::new(
      type         => NF_CDP_TYPE_MANAGEMENT_ADDR,
      length       => 8,
      numAddresses => 0,
      addresses    => [],
      @_,
   );
}

sub getLength {
   my $self = shift;

   my $length = 8;
   $length += $_->getLength for $self->addresses;

   return $length
}

sub pack {
   my $self = shift;

   my $raw = $self->SUPER::pack('nnN',
      $self->type,
      $self->length,
      $self->numAddresses
   ) or return;

   for ($self->addresses) {
      $raw .= $_->pack;
   }

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

sub _unpackAddresses {
   my $self = shift;
   my ($payload) = @_;

   my @addressesList;
   while (defined($payload) && length($payload)) {
      my $addr = Net::Frame::Layer::CDP::Address->new(raw => $payload)->unpack;
      push @addressesList, $addr;
      $payload = $addr->payload;
      $addr->payload(undef);
   }
   $self->addresses(\@addressesList);
   return $payload;
}

sub unpack {
   my $self = shift;

   my ($type, $length, $numAddresses, $tail) =
      $self->SUPER::unpack('nnN a*', $self->raw)
         or return;

   $self->type($type);
   $self->length($length);
   $self->numAddresses($numAddresses);

   my $valLen = $length - 8; # 4 + TLValue(4) then addresses array
   my ($addresses, $payload) =
      $self->SUPER::unpack("a$valLen a*", $tail)
         or return;

   $self->_unpackAddresses($addresses);

   $self->payload($payload);

   return $self;
}

sub computeLengths {
   my $self = shift;

   my $length = 8;
   $length += $_->getLength for $self->addresses;
   $self->length($length);

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

   return 1;
}

sub print {
   my $self = shift;

   my $l = $self->layer;
   my $buf = sprintf
      "$l: type:0x%04x  length:%d  numAddresses:%d",
         $self->type, $self->length, $self->numAddresses;

   for ($self->addresses) {
      $buf .=  "\n" . $_->print;
   }

   return $buf;
}

1;

__END__