view release on metacpan or  search on metacpan

lib/Metabrik/Network/Frame.pm  view on Meta::CPAN

         arp => [ qw(destination_ipv4_address|OPTIONAL destination_mac|OPTIONAL) ],
         eth => [ qw(destination_mac|OPTIONAL type|OPTIONAL) ],
         ipv4 => [ qw(destination_ipv4_address protocol|OPTIONAL source_ipv4_address|OPTIONAL) ],
         tcp => [ qw(destination_port source_port|OPTIONAL flags|OPTIONAL) ],
         udp => [ qw(destination_port source_port|OPTIONAL payload|OPTIONAL) ],
         icmpv4 => [ ],
         echo_icmpv4 => [ ],
         is_read => [ qw(data) ],
         is_simple => [ qw(data) ],
      },
      require_modules => {
         'Net::Frame::Simple' => [ ],
         'Net::Frame::Layer::ARP' => [ ],
         'Net::Frame::Layer::ETH' => [ ],
         'Net::Frame::Layer::IPv4' => [ ],
         'Net::Frame::Layer::IPv6' => [ ],
         'Net::Frame::Layer::TCP' => [ ],
         'Net::Frame::Layer::UDP' => [ ],
         'Net::Frame::Layer::ICMPv4' => [ ],
         'Net::Frame::Layer::ICMPv6' => [ ],
         'Metabrik::String::Hexa' => [ ],
         'Metabrik::Network::Device' => [ ],
      },
   };
}

sub brik_use_properties {
   my $self = shift;

   return {
      attributes_default => {
         device => defined($self->global) && $self->global->device || 'eth0',
      },
   };
}

sub brik_init {
   my $self = shift;

   $self->update_device_info
      or return $self->log->error("brik_init: update_device_info failed, you may not have a global device set");

   return $self->SUPER::brik_init(@_);
}

sub get_device_info {
   my $self = shift;
   my ($device) = @_;

   $device ||= $self->device;

   my $nd = Metabrik::Network::Device->new_from_brik_init($self) or return;

   my $device_info = $nd->get($device) or return;

   $self->log->debug("get_device_info: got info from device [$device]");

   return $device_info;
}

sub update_device_info {
   my $self = shift;
   my ($device) = @_;

   return $self->device_info($self->get_device_info($device));
}

sub from_read {
   my $self = shift;
   my ($frames) = @_;

   $self->brik_help_run_undef_arg('from_read', $frames) or return;
   my $ref = $self->brik_help_run_invalid_arg('from_read', $frames, 'HASH', 'ARRAY')
      or return;

   # We accept a one frame Argument...
   if ($ref eq 'HASH') {
      if (! exists($frames->{raw})
      ||  ! exists($frames->{firstLayer})
      ||  ! exists($frames->{timestamp})) {
         return $self->log->error("from_read: frames Argument is not an array of valid next HASHREFs");
      }
      else {
         return Net::Frame::Simple->newFromDump($frames);
      }
   }

   # Or an ARRAY or frames
   if ($ref ne 'ARRAY') {
      return $self->log->error("from_read: frames Argument must be an ARRAYREF");
   }
   if (@$frames <= 0) {
      return $self->log->error("from_read: frames Argument is empty");
   }
   my $first = $frames->[0];
   if (ref($first) ne 'HASH') {
      return $self->log->error("from_read: frames Argument is not an array of next HASHREFs");
   }
   if (! exists($first->{raw})
   ||  ! exists($first->{firstLayer})
   ||  ! exists($first->{timestamp})) {
      return $self->log->error("from_read: frames Argument is not an array of valid next HASHREFs");
   }

   my @simple = ();
   for my $h (@$frames) {
      my $simple = Net::Frame::Simple->newFromDump($h) or next;
      push @simple, $simple;
   }

   return \@simple;
}

sub to_read {
   my $self = shift;
   my ($frame) = @_;

   $self->brik_help_run_undef_arg('to_read', $frame) or return;
   my $ref = $self->brik_help_run_invalid_arg('to_read', $frame, 'ARRAY', 'Net::Frame::Simple')
      or return;