Net::Packet::Layer - base class for all layer modules

Net-Packet documentation Contained in the Net-Packet distribution.

Index

Code Index:

NAME

Top

Net::Packet::Layer - base class for all layer modules

DESCRIPTION

Top

This is the base class for Net::Packet::Layer2, Net::Packet::Layer3, Net::Packet::Layer4 and Net::Packet::Layer7 modules.

It just provides those layers with inheritable attributes and methods.

ATTRIBUTES

Top

raw

Stores the raw layer (as captured from the network, or packed to send to network).

payload

Stores what is not part of the layer, that is the encapsulated part to be decoded by upper layers.

METHODS

Top

is

Returns the string describing the layer type (example: 'IPv4').

layer

Returns the string describing the layer number (example: 'L3' for IPv4).

encapsulate

Returns the next layer type (parsed from payload). This is the same string as returned by is method.

computeLengths
computeChecksums

Generally, when a layer is built, some attributes are not yet known until the full Net::Packet::Frame is assembled. Those methods computes various lengths and checksums attributes found in a specific layer. Return 1 on success, undef otherwise.

print

Just returns a string in a human readable format describing attributes found in the layer.

dump

Just returns a string in hexadecimal format which is how the layer appears on the network.

getKey
getKeyReverse

These methods are used to respectively store and retrieve analyzed frames respectively to and from a hashref. This is to make it quick to get possible responses from a probe.

pack

Will pack all attributes into raw network format. This method MUST be implemented into each supported layers.

unpack

Will unpack raw network format to respective attributes. This method MUST be implemented into each supported layers.

getLength

Returns the layer length in bytes.

getPayloadLength

Returns the total length of remaining raw data in bytes (without calling layer length).

isLayer2
isLayer3
isLayer4
isLayer7

Returns true if the calling object is, respectively, layer 2, 3, 4 or 7.

CONSTANTS

Top

Load them: use Net::Packet::Consts qw(:layer);

NP_LAYER

Base layer string.

NP_LAYER_ETH
NP_LAYER_NULL
NP_LAYER_RAW
NP_LAYER_SLL

Layer 2 strings.

NP_LAYER_ARP
NP_LAYER_IPv4
NP_LAYER_IPv6
NP_LAYER_VLAN
NP_LAYER_PPPoE
NP_LAYER_PPP
NP_LAYER_LLC

Layer 3 strings.

NP_LAYER_TCP
NP_LAYER_UDP
NP_LAYER_ICMPv4
NP_LAYER_PPPLCP
NP_LAYER_CDP

Layer 4 strings.

NP_LAYER_7

Layer 7 string.

NP_LAYER_NONE
NP_LAYER_UNKNOWN

Other strings.

NP_LAYER_N_2
NP_LAYER_N_3
NP_LAYER_N_4
NP_LAYER_N_7
NP_LAYER_N_UNKNOWN

Layer number N strings.

AUTHOR

Top

Patrice <GomoR> Auffret

COPYRIGHT AND LICENSE

Top

Copyright (c) 2004-2009, Patrice <GomoR> Auffret

You may distribute this module under the terms of the Artistic license. See LICENSE.Artistic file in the source distribution archive.

RELATED MODULES

Top

NetPacket, Net::RawIP, Net::RawSock

Net-Packet documentation Contained in the Net-Packet distribution. 
#
# $Id: Layer.pm 1640 2009-11-09 17:58:27Z gomor $
#
package Net::Packet::Layer;
use strict;
use warnings;
use Carp;

require Class::Gomor::Array;
our @ISA = qw(Class::Gomor::Array);

use Net::Packet::Consts qw(:layer);

our @AS = qw(
   raw
   payload
);
__PACKAGE__->cgBuildIndices;
__PACKAGE__->cgBuildAccessorsScalar(\@AS);

no strict 'vars';

sub new {
   my $self = shift->SUPER::new(@_);
   $self->unpack if $self->raw;
   $self;
}

sub is {
   my $layer = ref(shift);
   $layer =~ s/^Net::Packet:://;
   $layer;
}

sub pack {
   my $self = shift;
   my ($fmt, @args) = @_;
   my $res;
   eval { $res = CORE::pack($fmt, @args) };
   $@ ? do { carp("@{[ref($self)]}: unable to pack structure\n"); undef }
      : $res;
}

sub unpack {
   my $self = shift;
   my ($fmt, $arg) = @_;
   my @res;
   eval { @res = CORE::unpack($fmt, $arg) };
   $@ ? do { carp("@{[ref($self)]}: unable to unpack structure\n"); () }
      : @res;
}

sub getPayloadLength {
   my $self = shift;
   $self->[$__payload] ? length($self->[$__payload]) : 0;
}

sub layer            { NP_LAYER_N_UNKNOWN }
sub encapsulate      { NP_LAYER_NONE      }
sub getKey           { shift->is          }
sub getKeyReverse    { shift->is          }
sub computeLengths   { 1                  }
sub computeChecksums { 1                  }
sub print            { ""                 }
sub getLength        { 0                  }

sub dump {
   my $self = shift;

   my $hex = CORE::unpack('H*', $self->raw);
   $hex =~ s/(..)/\\x$1/g;
   $hex =~ s/\\x$//;
   sprintf "@{[$self->layer]}:+@{[$self->is]}: \"$hex\"";
}

sub _isLayer { shift->layer eq shift()       }
sub isLayer2 { shift->_isLayer(NP_LAYER_N_2) }
sub isLayer3 { shift->_isLayer(NP_LAYER_N_3) }
sub isLayer4 { shift->_isLayer(NP_LAYER_N_4) }
sub isLayer7 { shift->_isLayer(NP_LAYER_N_7) }

1;

__END__