File Coverage

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

Criterion	Covered	Total	%
statement	137	170	80.5
branch	4	34	11.7
condition	0	26	0.0
subroutine	44	49	89.8
pod	10	10	100.0
total	195	289	67.4

#
# $Id: ICMPv4.pm 53 2012-01-31 20:27:06Z gomor $
#
package Net::Frame::Layer::ICMPv4;
use strict; use warnings;

our $VERSION = '1.04';

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

our %EXPORT_TAGS = (
   consts => [qw(
      NF_ICMPv4_HDR_LEN
      NF_ICMPv4_CODE_ZERO
      NF_ICMPv4_TYPE_DESTUNREACH
      NF_ICMPv4_CODE_NETWORK
      NF_ICMPv4_CODE_HOST
      NF_ICMPv4_CODE_PROTOCOL
      NF_ICMPv4_CODE_PORT
      NF_ICMPv4_CODE_FRAGMENTATION_NEEDED
      NF_ICMPv4_CODE_SOURCE_ROUTE_FAILED
      NF_ICMPv4_TYPE_TIMEEXCEED
      NF_ICMPv4_CODE_TTL_IN_TRANSIT
      NF_ICMPv4_CODE_FRAGMENT_REASSEMBLY
      NF_ICMPv4_TYPE_PARAMETERPROBLEM
      NF_ICMPv4_CODE_POINTER
      NF_ICMPv4_TYPE_SOURCEQUENCH
      NF_ICMPv4_TYPE_REDIRECT
      NF_ICMPv4_CODE_FOR_NETWORK
      NF_ICMPv4_CODE_FOR_HOST
      NF_ICMPv4_CODE_FOR_TOS_AND_NETWORK
      NF_ICMPv4_CODE_FOR_TOS_AND_HOST
      NF_ICMPv4_TYPE_ECHO_REQUEST
      NF_ICMPv4_TYPE_ECHO_REPLY
      NF_ICMPv4_TYPE_TIMESTAMP_REQUEST
      NF_ICMPv4_TYPE_TIMESTAMP_REPLY
      NF_ICMPv4_TYPE_INFORMATION_REQUEST
      NF_ICMPv4_TYPE_INFORMATION_REPLY
      NF_ICMPv4_TYPE_ADDRESS_MASK_REQUEST
      NF_ICMPv4_TYPE_ADDRESS_MASK_REPLY
   )],
);
our @EXPORT_OK = (
   @{$EXPORT_TAGS{consts}},
);

use constant NF_ICMPv4_HDR_LEN                      => 8;
use constant NF_ICMPv4_CODE_ZERO                    => 0;
use constant NF_ICMPv4_TYPE_DESTUNREACH             => 3;
use constant NF_ICMPv4_CODE_NETWORK                 => 0;
use constant NF_ICMPv4_CODE_HOST                    => 1;
use constant NF_ICMPv4_CODE_PROTOCOL                => 2;
use constant NF_ICMPv4_CODE_PORT                    => 3;
use constant NF_ICMPv4_CODE_FRAGMENTATION_NEEDED    => 4;
use constant NF_ICMPv4_CODE_SOURCE_ROUTE_FAILED     => 5;
use constant NF_ICMPv4_TYPE_TIMEEXCEED              => 11;
use constant NF_ICMPv4_CODE_TTL_IN_TRANSIT          => 0;
use constant NF_ICMPv4_CODE_FRAGMENT_REASSEMBLY     => 1;
use constant NF_ICMPv4_TYPE_PARAMETERPROBLEM        => 12;
use constant NF_ICMPv4_CODE_POINTER                 => 0;
use constant NF_ICMPv4_TYPE_SOURCEQUENCH            => 4;
use constant NF_ICMPv4_TYPE_REDIRECT                => 5;
use constant NF_ICMPv4_CODE_FOR_NETWORK             => 0;
use constant NF_ICMPv4_CODE_FOR_HOST                => 1;
use constant NF_ICMPv4_CODE_FOR_TOS_AND_NETWORK     => 2;
use constant NF_ICMPv4_CODE_FOR_TOS_AND_HOST        => 3;
use constant NF_ICMPv4_TYPE_ECHO_REQUEST            => 8;
use constant NF_ICMPv4_TYPE_ECHO_REPLY              => 0;
use constant NF_ICMPv4_TYPE_TIMESTAMP_REQUEST       => 13;
use constant NF_ICMPv4_TYPE_TIMESTAMP_REPLY         => 14;
use constant NF_ICMPv4_TYPE_INFORMATION_REQUEST     => 15;
use constant NF_ICMPv4_TYPE_INFORMATION_REPLY       => 16;
use constant NF_ICMPv4_TYPE_ADDRESS_MASK_REQUEST    => 17; # RFC 950
use constant NF_ICMPv4_TYPE_ADDRESS_MASK_REPLY      => 18; # RFC 950

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

use Net::Frame::Layer::ICMPv4::AddressMask;
use Net::Frame::Layer::ICMPv4::DestUnreach;
use Net::Frame::Layer::ICMPv4::Echo;
use Net::Frame::Layer::ICMPv4::Information;
use Net::Frame::Layer::ICMPv4::Redirect;
use Net::Frame::Layer::ICMPv4::TimeExceed;
use Net::Frame::Layer::ICMPv4::Timestamp;

sub new {
   my $self = shift->SUPER::new(
      type     => NF_ICMPv4_TYPE_ECHO_REQUEST,
      code     => NF_ICMPv4_CODE_ZERO,
      checksum => 0,
      @_,
   );

   return $self;
}

sub match {
   my $self = shift;
   my ($with) = @_;
   my $sType = $self->type;
   my $wType = $with->type;
   if ($sType eq NF_ICMPv4_TYPE_ECHO_REQUEST
   &&  $wType eq NF_ICMPv4_TYPE_ECHO_REPLY) {
      return 1;
   }
   elsif ($sType eq NF_ICMPv4_TYPE_TIMESTAMP_REQUEST
      &&  $wType eq NF_ICMPv4_TYPE_TIMESTAMP_REPLY) {
      return 1;
   }
   elsif ($sType eq NF_ICMPv4_TYPE_INFORMATION_REQUEST
      &&  $wType eq NF_ICMPv4_TYPE_INFORMATION_REPLY) {
      return 1;
   }
   elsif ($sType eq NF_ICMPv4_TYPE_ADDRESS_MASK_REQUEST
      &&  $wType eq NF_ICMPv4_TYPE_ADDRESS_MASK_REPLY) {
      return 1;
   }
   0;
}

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

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;
   for my $l (@$layers) {
      if ($l->layer =~ /ICMPv4::/) { $icmpType = $l; last; }
   }

   my $packed = $self->SUPER::pack('CCna*',
      $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_ICMPv4_TYPE_ECHO_REQUEST
      ||  $type eq NF_ICMPv4_TYPE_ECHO_REPLY) {
         return 'ICMPv4::Echo';
      }
      elsif ($type eq NF_ICMPv4_TYPE_TIMESTAMP_REQUEST
         ||  $type eq NF_ICMPv4_TYPE_TIMESTAMP_REPLY) {
         return 'ICMPv4::Timestamp';
      }
      elsif ($type eq NF_ICMPv4_TYPE_INFORMATION_REQUEST
         ||  $type eq NF_ICMPv4_TYPE_INFORMATION_REPLY) {
         return 'ICMPv4::Information';
      }
      elsif ($type eq NF_ICMPv4_TYPE_ADDRESS_MASK_REQUEST
         ||  $type eq NF_ICMPv4_TYPE_ADDRESS_MASK_REPLY) {
         return 'ICMPv4::AddressMask';
      }
      elsif ($type eq NF_ICMPv4_TYPE_DESTUNREACH) {
         return 'ICMPv4::DestUnreach';
      }
      elsif ($type eq NF_ICMPv4_TYPE_REDIRECT) {
         return 'ICMPv4::Redirect';
      }
      elsif ($type eq NF_ICMPv4_TYPE_TIMEEXCEED) {
         return 'ICMPv4::TimeExceed';
      }
   }

   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__