File Coverage

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

Criterion	Covered	Total	%
statement	143	221	64.7
branch	2	60	3.3
condition	0	35	0.0
subroutine	47	54	87.0
pod	10	10	100.0
total	202	380	53.1

#
# $Id: ICMPv6.pm 45 2014-04-09 06:32:08Z gomor $
#
package Net::Frame::Layer::ICMPv6;
use strict; use warnings;

our $VERSION = '1.09';

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

our %EXPORT_TAGS = (
   consts => [qw(
      NF_ICMPv6_CODE_ZERO
      NF_ICMPv6_TYPE_DESTUNREACH
      NF_ICMPv6_CODE_NOROUTE
      NF_ICMPv6_CODE_ADMINPROHIBITED
      NF_ICMPv6_CODE_NOTASSIGNED
      NF_ICMPv6_CODE_ADDRESSUNREACH
      NF_ICMPv6_CODE_PORTUNREACH
      NF_ICMPv6_CODE_FAILPOLICY
      NF_ICMPv6_CODE_REJECTROUTE
      NF_ICMPv6_TYPE_TOOBIG
      NF_ICMPv6_TYPE_TIMEEXCEED
      NF_ICMPv6_CODE_HOPLIMITEXCEED
      NF_ICMPv6_CODE_FRAGREASSEMBLYEXCEEDED
      NF_ICMPv6_TYPE_PARAMETERPROBLEM
      NF_ICMPv6_CODE_ERRONEOUSHERDERFIELD
      NF_ICMPv6_CODE_UNKNOWNNEXTHEADER
      NF_ICMPv6_CODE_UNKNOWNOPTION
      NF_ICMPv6_TYPE_ECHO_REQUEST
      NF_ICMPv6_TYPE_ECHO_REPLY
      NF_ICMPv6_TYPE_ROUTERSOLICITATION
      NF_ICMPv6_TYPE_ROUTERADVERTISEMENT
      NF_ICMPv6_TYPE_NEIGHBORSOLICITATION
      NF_ICMPv6_TYPE_NEIGHBORADVERTISEMENT
      NF_ICMPv6_OPTION_SOURCELINKLAYERADDRESS
      NF_ICMPv6_OPTION_TARGETLINKLAYERADDRESS
      NF_ICMPv6_OPTION_PREFIXINFORMATION
      NF_ICMPv6_OPTION_REDIRECTEDHEADER
      NF_ICMPv6_OPTION_MTU
      NF_ICMPv6_FLAG_ROUTER
      NF_ICMPv6_FLAG_SOLICITED
      NF_ICMPv6_FLAG_OVERRIDE
      NF_ICMPv6_FLAG_MANAGEDADDRESSCONFIGURATION
      NF_ICMPv6_FLAG_OTHERCONFIGURATION
   )],
);
our @EXPORT_OK = (
   @{$EXPORT_TAGS{consts}},
);

use constant NF_ICMPv6_CODE_ZERO                    => 0;
use constant NF_ICMPv6_TYPE_DESTUNREACH             => 1;
use constant NF_ICMPv6_CODE_NOROUTE                 => 0;
use constant NF_ICMPv6_CODE_ADMINPROHIBITED         => 1;
use constant NF_ICMPv6_CODE_NOTASSIGNED             => 2;
use constant NF_ICMPv6_CODE_ADDRESSUNREACH          => 3;
use constant NF_ICMPv6_CODE_PORTUNREACH             => 4;
use constant NF_ICMPv6_CODE_FAILPOLICY              => 5;
use constant NF_ICMPv6_CODE_REJECTROUTE             => 6;
use constant NF_ICMPv6_TYPE_TOOBIG                  => 2;
use constant NF_ICMPv6_TYPE_TIMEEXCEED              => 3;
use constant NF_ICMPv6_CODE_HOPLIMITEXCEED          => 0;
use constant NF_ICMPv6_CODE_FRAGREASSEMBLYEXCEEDED  => 1;
use constant NF_ICMPv6_TYPE_PARAMETERPROBLEM        => 4;
use constant NF_ICMPv6_CODE_ERRONEOUSHERDERFIELD    => 0;
use constant NF_ICMPv6_CODE_UNKNOWNNEXTHEADER       => 1;
use constant NF_ICMPv6_CODE_UNKNOWNOPTION           => 2;
use constant NF_ICMPv6_TYPE_ECHO_REQUEST            => 128;
use constant NF_ICMPv6_TYPE_ECHO_REPLY              => 129;
use constant NF_ICMPv6_TYPE_ROUTERSOLICITATION      => 133;
use constant NF_ICMPv6_TYPE_ROUTERADVERTISEMENT     => 134;
use constant NF_ICMPv6_TYPE_NEIGHBORSOLICITATION    => 135;
use constant NF_ICMPv6_TYPE_NEIGHBORADVERTISEMENT   => 136;

use constant NF_ICMPv6_OPTION_SOURCELINKLAYERADDRESS => 0x01;
use constant NF_ICMPv6_OPTION_TARGETLINKLAYERADDRESS => 0x02;
use constant NF_ICMPv6_OPTION_PREFIXINFORMATION      => 0x03;
use constant NF_ICMPv6_OPTION_REDIRECTEDHEADER       => 0x04;
use constant NF_ICMPv6_OPTION_MTU                    => 0x05;

use constant NF_ICMPv6_FLAG_ROUTER    => 0x04;
use constant NF_ICMPv6_FLAG_SOLICITED => 0x02;
use constant NF_ICMPv6_FLAG_OVERRIDE  => 0x01;

use constant NF_ICMPv6_FLAG_MANAGEDADDRESSCONFIGURATION => 1 << 5;
use constant NF_ICMPv6_FLAG_OTHERCONFIGURATION          => 1 << 4;
use constant NF_ICMPv6_FLAG_MOBILEIPv6HOMEAGENT         => 1 << 3;
use constant NF_ICMPv6_FLAG_ROUTERSELECTIONPREFHIGH     => 1 << 1; # 01b
use constant NF_ICMPv6_FLAG_ROUTERSELECTIONPREFMEDIUM   => 0;      # 00b
use constant NF_ICMPv6_FLAG_ROUTERSELECTIONPREFLOW      => 3 << 1; # 11b
use constant NF_ICMPv6_FLAG_ROUTERSELECTIONPREFRESERVED => 2 << 1; # 10b
use constant NF_ICMPv6_FLAG_NEIGHBORDISCOVERYPROXY      => 1;

our @AS = qw(
   type
   code
   checksum
);
__PACKAGE__->cgBuildIndices;
__PACKAGE__->cgBuildAccessorsScalar(\@AS);

use Bit::Vector;

sub new {
   shift->SUPER::new(
      type     => NF_ICMPv6_TYPE_ECHO_REQUEST,
      code     => NF_ICMPv6_CODE_ZERO,
      checksum => 0,
      @_,
   );
}

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

sub match {
   my $self = shift;
   my ($with) = @_;
   my $sType = $self->type;
   my $wType = $with->type;
   if ($sType eq NF_ICMPv6_TYPE_ECHO_REQUEST
   &&  $wType eq NF_ICMPv6_TYPE_ECHO_REPLY) {
      return 1;
   }
   elsif ($sType eq NF_ICMPv6_TYPE_NEIGHBORSOLICITATION
      &&  $wType eq NF_ICMPv6_TYPE_NEIGHBORADVERTISEMENT) {
      return 1;
   }
   elsif ($sType eq NF_ICMPv6_TYPE_ROUTERSOLICITATION
      &&  $wType eq NF_ICMPv6_TYPE_ROUTERADVERTISEMENT) {
      return 1;
   }
   return 0;
}

sub getLength { 4 }

sub pack {
   my $self = shift;

   my $raw = $self->SUPER::pack('CCn',
      $self->type, $self->code, $self->checksum,
   ) or return;

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

sub unpack {
   my $self = shift;

   my ($type, $code, $checksum, $payload) =
      $self->SUPER::unpack('CCn a*', $self->raw)
         or return;

   $self->type($type);
   $self->code($code);
   $self->checksum($checksum);
   $self->payload($payload);

   return $self;
}

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

   my $icmpType;
   my $ip;
   my $rh0;
   my $hbh; # Hop-by-hop Ext Hdr
   my $dst; # Destination Ext Hdr
   my $mob; # Mobility Ext Hdr
   my $lastNextHeader;
   my $fragmentFlag = 0;
   for my $l (@$layers) {
      if (! $icmpType && $l->layer =~ /ICMPv6::/)          { $icmpType = $l; }
      if (! $ip       && $l->layer eq 'IPv6')              { $ip       = $l; }
      if (! $rh0      && $l->layer eq 'IPv6::Routing')     { $rh0      = $l; }
      if (! $hbh      && $l->layer eq 'IPv6::HopByHop')    { $hbh      = $l; }
      if (! $dst      && $l->layer eq 'IPv6::Destination') { $dst      = $l; }
      if (! $mob      && $l->layer eq 'IPv6::Mobility')    { $mob      = $l; }

      if ($l->can('nextHeader')) { $lastNextHeader = $l->nextHeader; }

      if ($l->layer eq 'IPv6::Fragment') { $fragmentFlag = 1; }
   }

   my $lastIpDst       = $ip->dst;
   my $ipPayloadLength = $ip->payloadLength;
   # If RH0, need to set $ip->dst to last $rh0->addresses
   # unless segmentsLeft == 0 (RFC 2460 sec 8.1)
   if ($rh0 && $rh0->segmentsLeft != 0) {
      for ($rh0->addresses) {
         $lastIpDst = $_;
      }
      # Pseudo header length is upper layer minus any EH (RFC 2460 sec 8.1)
      $ipPayloadLength -= $rh0->getLength;
   }
   # Pseudo header length is upper layer minus any EH (RFC 2460 sec 8.1)
   if ($fragmentFlag) {
      $ipPayloadLength -= 8; # 8 = length of fragment EH
   }
   if ($hbh) {
      $ipPayloadLength -= $hbh->getLength;
   }
   if ($dst) {
      $ipPayloadLength -= $dst->getLength;
   }
   if ($mob) {
      $ipPayloadLength -= $mob->getLength;
   }

   # Build pseudo-header and pack ICMPv6 packet
   my $zero       = Bit::Vector->new_Dec(24, 0);
   my $nextHeader = Bit::Vector->new_Dec( 8, $lastNextHeader);
   my $v32        = $zero->Concat_List($nextHeader);

   my $packed = $self->SUPER::pack('a*a*NNCCna*',
      inet6Aton($ip->src), inet6Aton($lastIpDst), $ipPayloadLength,
      $v32->to_Dec, $self->type, $self->code, 0, $icmpType->pack,
   ) or return;

   my $payload = $layers->[-1]->payload || '';
   $self->checksum(inetChecksum($packed.$payload));

   return 1;
}

sub encapsulate {
   my $self = shift;

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

   if ($self->payload) {
      my $type = $self->type;
#     if ($type eq NF_ICMPv6_TYPE_REDIRECT) {
#        return 'IPv6';
#     }
      if ($type eq NF_ICMPv6_TYPE_ECHO_REQUEST
      ||  $type eq NF_ICMPv6_TYPE_ECHO_REPLY) {
         return 'ICMPv6::Echo';
      }
      elsif ($type eq NF_ICMPv6_TYPE_NEIGHBORSOLICITATION) {
         return 'ICMPv6::NeighborSolicitation';
      }
      elsif ($type eq NF_ICMPv6_TYPE_NEIGHBORADVERTISEMENT) {
         return 'ICMPv6::NeighborAdvertisement';
      }
      elsif ($type eq NF_ICMPv6_TYPE_ROUTERSOLICITATION) {
         return 'ICMPv6::RouterSolicitation';
      }
      elsif ($type eq NF_ICMPv6_TYPE_ROUTERADVERTISEMENT) {
         return 'ICMPv6::RouterAdvertisement';
      }
      elsif ($type eq NF_ICMPv6_TYPE_DESTUNREACH) {
         return 'ICMPv6::DestUnreach';
      }
      elsif ($type eq NF_ICMPv6_TYPE_TIMEEXCEED) {
         return 'ICMPv6::TimeExceed';
      }
      elsif ($type eq NF_ICMPv6_TYPE_TOOBIG) {
         return 'ICMPv6::TooBig';
      }
      elsif ($type eq NF_ICMPv6_TYPE_PARAMETERPROBLEM) {
         return 'ICMPv6::ParameterProblem';
      }
   }

   return NF_LAYER_NONE;
}

sub print {
   my $self = shift;

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

   return $buf;
}

1;

__END__