File Coverage

blib/lib/Nmap/Parser.pm

Criterion	Covered	Total	%
statement	4	6	66.6
branch			n/a
condition			n/a
subroutine	2	2	100.0
pod			n/a
total	6	8	75.0

package Nmap::Parser;

use strict;
use XML::Twig;

our $VERSION = 1.34;


sub new {

    my ( $class, $self ) = shift;
    $class = ref($class) || $class;

    $self->{twig} = new XML::Twig(
        start_tag_handlers => { nmaprun => sub {$self->_nmaprun_start_tag_hdlr(@_)} },

        twig_roots => {
            scaninfo => sub {$self->_scaninfo_tag_hdlr(@_)},
            prescript => sub {$self->_prescript_tag_hdlr(@_)},
            postscript => sub {$self->_postscript_tag_hdlr(@_)},
            finished => sub {$self->_finished_tag_hdlr(@_)},
            host     => sub {$self->_host_tag_hdlr(@_)},
        },
        ignore_elts => {
            addport      => 1,
            debugging    => 1,
            verbose      => 1,
            hosts        => 1,
            taskbegin    => 1,
            taskend      => 1,
            taskprogress => 1
        }
    );

    bless( $self, $class );
    return $self;
}

#/*****************************************************************************/
# NMAP::PARSER OBJECT METHODS
#/*****************************************************************************/

#Safe parse and parsefile will return $@ which will contain the error
#that occured if the parsing failed (it might be empty when no error occurred)

sub callback {
    my $self     = shift;
    my $callback = shift;    #first arg is CODE
    if ( ref($callback) eq 'CODE' ) {
        $self->{callback}{coderef}       = $callback;
        $self->{callback}{is_registered} = 1;
    }
    else {
        $self->{callback}{is_registered} = 0;
    }

    #returns if a callback is registered or not
    return $self->{callback}{is_registered};
}

sub _parse {
    my $type = shift;
    my $self = shift;
    $self->{HOSTS} = undef;
    $self->{SESSION} = undef;
    {
        file => sub { $self->{twig}->safe_parsefile(@_); },
        string => sub { $self->{twig}->safe_parse(@_); },
    }->{$type}->(@_);
    if ($@) { die $@; }
    $self->purge;
    return $self;
}

sub parse {
    return _parse('string', @_);
}

sub parsefile {
    return _parse('file', @_);
}

sub parsescan {
    my $self = shift;
    my $nmap = shift;
    my $args = shift;
    my @ips  = @_;
    my $FH;

    if ( $args =~ /-o(?:X|N|G)/ ) {
        die
"[Nmap-Parser] Cannot pass option '-oX', '-oN' or '-oG' to parsecan()";
    }

    my $cmd;

#if output file is defined, point it to a localfile then call parsefile instead.
    if ( defined( $self->{cache_file} ) ) {
        $cmd =
            "$nmap $args -v -v -v -oX "
          . $self->{cache_file} . " "
          . ( join ' ', @ips );
        `$cmd`;    #remove output from STDOUT
        $self->parsefile( $self->{cache_file} );
    }
    else {
        $cmd = "$nmap $args -v -v -v -oX - " . ( join ' ', @ips );
        open $FH,
          "$cmd |" || die "[Nmap-Parser] Could not perform nmap scan - $!";
        $self->parse($FH);
        close $FH;
    }

    return $self;
}

sub cache_scan {
    my $self = shift;
    $self->{cache_file} = shift || 'nmap-parser-cache.' . time() . '.xml';
}

sub purge {
    my $self = shift;
    $self->{twig}->purge;
    return $self;
}

sub addr_sort {
    my $self = shift if ref $_[0];

    return (
        map { unpack("x16A*", $_) }
            sort { $a cmp $b }
            map {
                my @vals;
                if( /:/ ) { #IPv6
                    @vals = split /:/;
                    @vals = map { $_ eq '' ? (0) x (8-$#vals) : hex } @vals
                } else { #IPv4
                    my @v4 = split /\./;
                    # Sort as IPv4-mapped IPv6, per RFC 4291 Section 2.5.5.2
                    @vals = ( (0) x 5, 0xffff, map { 256*$v4[$_] + $v4[$_+1] } (0,2) );
                }
                pack("n8A*", @vals, $_)
            } @_
        );
}

#MAIN SCAN INFORMATION
sub get_session {
    my $self = shift;
    my $obj  = Nmap::Parser::Session->new( $self->{SESSION} );
    return $obj;
}

#HOST STUFF
sub get_host {
    my ( $self, $ip ) = (@_);
    if ( $ip eq '' ) {
        warn "[Nmap-Parser] No IP address given to get_host()\n";
        return undef;
    }
    $self->{HOSTS}{$ip};
}

sub del_host {
    my ( $self, $ip ) = (@_);
    if ( $ip eq '' ) {
        warn "[Nmap-Parser] No IP address given to del_host()\n";
        return undef;
    }
    delete $self->{HOSTS}{$ip};
}

sub all_hosts {
    my $self = shift;
    my $status = shift || '';

    return ( values %{ $self->{HOSTS} } ) if ( $status eq '' );

    my @hosts = grep { $_->{status} eq $status } ( values %{ $self->{HOSTS} } );
    return @hosts;
}

sub get_ips {
    my $self = shift;
    my $status = shift || '';

    return $self->addr_sort( keys %{ $self->{HOSTS} } ) if ( $status eq '' );

    my @hosts =
      grep { $self->{HOSTS}{$_}{status} eq $status }
      ( keys %{ $self->{HOSTS} } );
    return $self->addr_sort(@hosts);

}

#/*****************************************************************************/
# PARSING TAG HANDLERS FOR XML::TWIG
#/*****************************************************************************/

sub _nmaprun_start_tag_hdlr {

    my ($self, $twig, $tag ) = @_;

    $self->{SESSION}{start_time}   = $tag->{att}->{start};
    $self->{SESSION}{nmap_version} = $tag->{att}->{version};
    $self->{SESSION}{start_str}    = $tag->{att}->{startstr};
    $self->{SESSION}{xml_version}  = $tag->{att}->{xmloutputversion};
    $self->{SESSION}{scan_args}    = $tag->{att}->{args};
    $self->{SESSION} = Nmap::Parser::Session->new( $self->{SESSION} );

    $twig->purge;

}

sub _scaninfo_tag_hdlr {
    my ( $self, $twig, $tag ) = @_;
    my $type        = $tag->{att}->{type};
    my $proto       = $tag->{att}->{protocol};
    my $numservices = $tag->{att}->{numservices};

    if ( defined($type) ) {    #there can be more than one type in one scan
        $self->{SESSION}{type}{$type}        = $proto;
        $self->{SESSION}{numservices}{$type} = $numservices;
    }
    $twig->purge;
}

sub _prescript_tag_hdlr {
    my ($self, $twig, $tag ) = @_;
    my $scripts_hashref;
    for my $script ( $tag->children('script') ) {
        $scripts_hashref->{ $script->{att}->{id} } =
            __script_tag_hdlr( $script );
    }
    $self->{SESSION}{prescript} = $scripts_hashref;
    $twig->purge;
}

sub _postscript_tag_hdlr {
    my ($self, $twig, $tag ) = @_;
    my $scripts_hashref;
    for my $script ( $tag->children('script') ) {
        $scripts_hashref->{ $script->{att}->{id} } =
          __script_tag_hdlr( $script );
    }
    $self->{SESSION}{postscript} = $scripts_hashref;
    $twig->purge;
}

sub _finished_tag_hdlr {
    my ($self, $twig, $tag ) = @_;
    $self->{SESSION}{finish_time} = $tag->{att}->{time};
    $self->{SESSION}{time_str}    = $tag->{att}->{timestr};
    $twig->purge;
}

#parses all the host information in one swoop (calling __host_*_tag_hdlrs)
sub _host_tag_hdlr {
    my ($self, $twig, $tag ) = @_;
    my $id = undef;

    return undef unless ( defined $tag );

    #GET ADDRESS INFO
    my $addr_hashref;
    $addr_hashref = __host_addr_tag_hdlr($tag);

    #use this as the identifier
    $id =
         $addr_hashref->{ipv4}
      || $addr_hashref->{ipv6}
      || $addr_hashref->{mac};    #worstcase use MAC

    $self->{HOSTS}{$id}{addrs} = $addr_hashref;

    return undef unless ( defined($id) || $id ne '' );

    #GET HOSTNAMES
    $self->{HOSTS}{$id}{hostnames} = __host_hostnames_tag_hdlr($tag);

    #GET STATUS
    $self->{HOSTS}{$id}{status} = $tag->first_child('status')->{att}->{state};

    #CONTINUE PROCESSING IF STATUS IS UP - OTHERWISE NO MORE XML
    if ( lc( $self->{HOSTS}{$id}{status} ) eq 'up' ) {

        $self->{HOSTS}{$id}{ports}         = __host_port_tag_hdlr($tag);
        $self->{HOSTS}{$id}{os}            = __host_os_tag_hdlr($tag);
        $self->{HOSTS}{$id}{uptime}        = __host_uptime_tag_hdlr($tag);
        $self->{HOSTS}{$id}{tcpsequence}   = __host_tcpsequence_tag_hdlr($tag);
        $self->{HOSTS}{$id}{ipidsequence}  = __host_ipidsequence_tag_hdlr($tag);
        $self->{HOSTS}{$id}{tcptssequence} = __host_tcptssequence_tag_hdlr($tag);
        $self->{HOSTS}{$id}{hostscript} = __host_hostscript_tag_hdlr($tag);
        $self->{HOSTS}{$id}{distance} =
          __host_distance_tag_hdlr($tag);    #returns simple value
        $self->{HOSTS}{$id}{trace}         = __host_trace_tag_hdlr($tag);
        $self->{HOSTS}{$id}{trace_error}   = __host_trace_error_tag_hdlr($tag);
    }

    #CREATE HOST OBJECT FOR USER
    $self->{HOSTS}{$id} = Nmap::Parser::Host->new( $self->{HOSTS}{$id} );

    if ( $self->{callback}{is_registered} ) {
        &{ $self->{callback}{coderef} }( $self->{HOSTS}{$id} );
        delete $self->{HOSTS}{$id};
    }

    $twig->purge;

}

sub __host_addr_tag_hdlr {
    my $tag = shift;
    my $addr_hashref;

    #children() will return all children with tag name address
    for my $addr ( $tag->children('address') ) {
        if ( lc( $addr->{att}->{addrtype} ) eq 'mac' ) {

            #we'll assume for now, only 1 MAC address per system
            $addr_hashref->{mac}{addr}   = $addr->{att}->{addr};
            $addr_hashref->{mac}{vendor} = $addr->{att}->{vendor};
        }
        elsif ( lc( $addr->{att}->{addrtype} ) eq 'ipv4' ) {
            $addr_hashref->{ipv4} = $addr->{att}->{addr};
        }    #support for ipv6? we'll see
        elsif ( lc( $addr->{att}->{addrtype} ) eq 'ipv6' ) {
            $addr_hashref->{ipv6} = $addr->{att}->{addr};
        }

    }

    return $addr_hashref;
}

sub __host_hostnames_tag_hdlr {
    my $tag = shift;

    my $hostnames_tag = $tag->first_child('hostnames');
    return undef unless ( defined $hostnames_tag );

    my @hostnames;

    for my $name ( $hostnames_tag->children('hostname') ) {
        push @hostnames, $name->{att}->{name};
    }

    return \@hostnames;

}

sub __host_port_tag_hdlr {
    my $tag = shift;
    my ( $port_hashref, $ports_tag );

    $ports_tag = $tag->first_child('ports');

    return undef unless ( defined $ports_tag );

    #Parsing Extraports
    my $extraports_tag = $ports_tag->first_child('extraports');
    if ( defined $extraports_tag && $extraports_tag ne '' ) {
        $port_hashref->{extraports}{state} = $extraports_tag->{att}->{state};
        $port_hashref->{extraports}{count} = $extraports_tag->{att}->{count};
    }

    #Parsing regular port information

    my ( $tcp_port_count, $udp_port_count ) = ( 0, 0 );

    for my $port_tag ( $ports_tag->children('port') ) {
        my $proto  = $port_tag->{att}->{protocol};
        my $portid = $port_tag->{att}->{portid};
        my $state  = $port_tag->first_child('state');
        my $owner  = $port_tag->first_child('owner') || undef;

        $tcp_port_count++ if ( $proto eq 'tcp' );
        $udp_port_count++ if ( $proto eq 'udp' );

        $port_hashref->{$proto}{$portid}{state} = $state->{att}->{state}
          || 'unknown'
          if ( $state ne '' );

        $port_hashref->{$proto}{$portid}{reason_ttl} = $state->{att}->{reason_ttl}
          || 'unknown'
          if($state ne '');

        #GET SERVICE INFORMATION
        $port_hashref->{$proto}{$portid}{service} =
          __host_service_tag_hdlr( $port_tag, $portid )
          if ( defined($proto) && defined($portid) );

        #GET SCRIPT INFORMATION
        $port_hashref->{$proto}{$portid}{service}{script} =
          __host_script_tag_hdlr( $port_tag, $portid)
          if ( defined($proto) && defined($portid) );

        #GET OWNER INFORMATION
        $port_hashref->{$proto}{$portid}{service}{owner} = $owner->{att}->{name}
          if ( defined($owner) );

   #These are added at the end, otherwise __host_service_tag_hdlr will overwrite
   #GET PORT STATE

    }

    $port_hashref->{tcp_port_count} = $tcp_port_count;
    $port_hashref->{udp_port_count} = $udp_port_count;

    return $port_hashref;

}

sub __host_service_tag_hdlr {
    my $tag    = shift;
    my $portid = shift;   #need a way to remember what port this service runs on
    my $service = $tag->first_child('service[@name]');
    my $service_hashref;
    $service_hashref->{port} = $portid;

    if ( defined $service ) {
        $service_hashref->{name}      = $service->{att}->{name} || 'unknown';
        $service_hashref->{version}   = $service->{att}->{version};
        $service_hashref->{product}   = $service->{att}->{product};
	$service_hashref->{devicetype} = $service->{att}->{devicetype};
        $service_hashref->{extrainfo} = $service->{att}->{extrainfo};
        $service_hashref->{proto} =
             $service->{att}->{proto}
          || $service->{att}->{protocol}
          || 'unknown';
        $service_hashref->{rpcnum}      = $service->{att}->{rpcnum};
        $service_hashref->{tunnel}      = $service->{att}->{tunnel};
        $service_hashref->{method}      = $service->{att}->{method};
        $service_hashref->{confidence}  = $service->{att}->{conf};
        $service_hashref->{fingerprint} = $service->{att}->{servicefp};
    }

    return $service_hashref;
}

sub __host_script_tag_hdlr {
    my $tag = shift;
    my $script_hashref;

    for ( $tag->children('script') ) {
        $script_hashref->{ $_->{att}->{id} } =
         __script_tag_hdlr($_);
    }

    return $script_hashref;
}

sub __host_os_tag_hdlr {
    my $tag    = shift;
    my $os_tag = $tag->first_child('os');
    my $os_hashref;
    my $portused_tag;
    my $os_fingerprint;

    if ( defined $os_tag ) {

        #get the open port used to match os
        $portused_tag = $os_tag->first_child("portused[\@state='open']");
        $os_hashref->{portused}{open} = $portused_tag->{att}->{portid}
          if ( defined $portused_tag );

        #get the closed port used to match os
        $portused_tag = $os_tag->first_child("portused[\@state='closed']");
        $os_hashref->{portused}{closed} = $portused_tag->{att}->{portid}
          if ( defined $portused_tag );

        #os fingerprint
        $os_fingerprint = $os_tag->first_child("osfingerprint");
        $os_hashref->{os_fingerprint} =
          $os_fingerprint->{'att'}->{'fingerprint'}
          if ( defined $os_fingerprint );

        #This will go in Nmap::Parser::Host::OS
        my $osmatch_index = 0;
        my $osclass_index = 0;
        for my $osmatch ( $os_tag->children('osmatch') ) {
            $os_hashref->{osmatch_name}[$osmatch_index] =
              $osmatch->{att}->{name};
            $os_hashref->{osmatch_name_accuracy}[$osmatch_index] =
              $osmatch->{att}->{accuracy};
            $osmatch_index++;
            for my $osclass ( $osmatch->children('osclass') ) {
                $os_hashref->{osclass_osfamily}[$osclass_index] =
                  $osclass->{att}->{osfamily};
                $os_hashref->{osclass_osgen}[$osclass_index] =
                  $osclass->{att}->{osgen};
                $os_hashref->{osclass_vendor}[$osclass_index] =
                  $osclass->{att}->{vendor};
                $os_hashref->{osclass_type}[$osclass_index] =
                  $osclass->{att}->{type};
                $os_hashref->{osclass_class_accuracy}[$osclass_index] =
                  $osclass->{att}->{accuracy};
                $osclass_index++;
            }
        }
        $os_hashref->{'osmatch_count'} = $osmatch_index;

        #parse osclass tags
        for my $osclass ( $os_tag->children('osclass') ) {
            $os_hashref->{osclass_osfamily}[$osclass_index] =
              $osclass->{att}->{osfamily};
            $os_hashref->{osclass_osgen}[$osclass_index] =
              $osclass->{att}->{osgen};
            $os_hashref->{osclass_vendor}[$osclass_index] =
              $osclass->{att}->{vendor};
            $os_hashref->{osclass_type}[$osclass_index] =
              $osclass->{att}->{type};
            $os_hashref->{osclass_class_accuracy}[$osclass_index] =
              $osclass->{att}->{accuracy};
            $osclass_index++;
        }
        $os_hashref->{'osclass_count'} = $osclass_index;
    }

    return $os_hashref;

}

sub __host_uptime_tag_hdlr {
    my $tag    = shift;
    my $uptime = $tag->first_child('uptime');
    my $uptime_hashref;

    if ( defined $uptime ) {
        $uptime_hashref->{seconds}  = $uptime->{att}->{seconds};
        $uptime_hashref->{lastboot} = $uptime->{att}->{lastboot};

    }

    return $uptime_hashref;

}

sub __host_tcpsequence_tag_hdlr {
    my $tag      = shift;
    my $sequence = $tag->first_child('tcpsequence');
    my $sequence_hashref;
    return undef unless ($sequence);
    $sequence_hashref->{class}  = $sequence->{att}->{class};
    $sequence_hashref->{difficulty}  = $sequence->{att}->{difficulty};
    $sequence_hashref->{values} = $sequence->{att}->{values};
    $sequence_hashref->{index}  = $sequence->{att}->{index};

    return $sequence_hashref;

}

sub __host_ipidsequence_tag_hdlr {
    my $tag      = shift;
    my $sequence = $tag->first_child('ipidsequence');
    my $sequence_hashref;
    return undef unless ($sequence);
    $sequence_hashref->{class}  = $sequence->{att}->{class};
    $sequence_hashref->{values} = $sequence->{att}->{values};
    return $sequence_hashref;

}

sub __host_tcptssequence_tag_hdlr {
    my $tag      = shift;
    my $sequence = $tag->first_child('tcptssequence');
    my $sequence_hashref;
    return undef unless ($sequence);
    $sequence_hashref->{class}  = $sequence->{att}->{class};
    $sequence_hashref->{values} = $sequence->{att}->{values};
    return $sequence_hashref;
}

sub __host_hostscript_tag_hdlr {
    my $tag = shift;
    my $scripts = $tag->first_child('hostscript');
    my $scripts_hashref;
    return undef unless ($scripts);
    for my $script ( $scripts->children('script') ) {
        $scripts_hashref->{ $script->{att}->{id} } =
            __script_tag_hdlr( $script );
    }
    return $scripts_hashref;
}

sub __host_distance_tag_hdlr {
    my $tag      = shift;
    my $distance = $tag->first_child('distance');
    return undef unless ($distance);
    return $distance->{att}->{value};
}

sub __host_trace_tag_hdlr {
    my $tag           = shift;
    my $trace_tag     = $tag->first_child('trace');
    my $trace_hashref = { hops => [], };

    if ( defined $trace_tag ) {

        my $proto = $trace_tag->{att}->{proto};
        $trace_hashref->{proto} = $proto if defined $proto;

        my $port = $trace_tag->{att}->{port};
        $trace_hashref->{port} = $port if defined $port;

        for my $hop_tag ( $trace_tag->children('hop') ) {

            # Copy the known hop attributes, they will go in
            # Nmap::Parser::Host::TraceHop
            my %hop_data;
            $hop_data{$_} = $hop_tag->{att}->{$_} for qw( ttl rtt ipaddr host );
            delete $hop_data{rtt} if $hop_data{rtt} !~ /^[\d.]+$/;

            push @{ $trace_hashref->{hops} }, \%hop_data;
        }

    }

    return $trace_hashref;
}

sub __host_trace_error_tag_hdlr {
    my $tag       = shift;
    my $trace_tag = $tag->first_child('trace');

    if ( defined $trace_tag ) {

        my $error_tag = $trace_tag->first_child('error');
        if ( defined $error_tag ) {

            # If an error happens, always provide a true value even if
            # it doesn't contains a useful string
            my $errorstr = $error_tag->{att}->{errorstr} || 1;
            return $errorstr;
        }
    }

    return;
}

sub __script_tag_hdlr {
    my $tag = shift;
    my $script_hashref = {
        output => $tag->{att}->{output}
    };
    chomp %$script_hashref;
    if ( not $tag->is_empty()) {
        $script_hashref->{contents} = __script_table($tag);
    }
    return $script_hashref;
}

sub __script_table {
    my $tag = shift;
    my ($ref, $subref);
    my $fc = $tag->first_child();
    if ($fc) {
        if ($fc->is_text) {
            $ref = $fc->text;
        }
        else {
            if ($fc->{att}->{key}) {
                $ref = {};
                $subref = sub {
                    $ref->{$_->{att}->{key}} = shift;
                };
            }
            else {
                $ref = [];
                $subref = sub {
                    push @$ref, shift;
                };
            }
            for ($tag->children()) {
                if ($_->tag() eq "table") {
                    $subref->(__script_table( $_ ));
                }
                else {
                    $subref->($_->text);
                }
            }
        }
    }
    return $ref
}

#/*****************************************************************************/
# NMAP::PARSER::SESSION
#/*****************************************************************************/

package Nmap::Parser::Session;
use vars qw($AUTOLOAD);

sub new {
    my $class = shift;
    $class = ref($class) || $class;
    my $self = shift || {};
    bless( $self, $class );
    return $self;
}

#Support for:
#start_time, start_str, finish_time, time_str, nmap_version, xml_version, scan_args
sub AUTOLOAD {
    ( my $param = $AUTOLOAD ) =~ s{.*::}{}xms;
    return if ( $param eq 'DESTROY' );
    no strict 'refs';
    *$AUTOLOAD = sub { return $_[0]->{ lc $param } };
    goto &$AUTOLOAD;
}

sub numservices {
    my $self = shift;
    my $type = shift
      || '';   #(syn|ack|bounce|connect|null|xmas|window|maimon|fin|udp|ipproto)

    return unless ( ref( $self->{numservices} ) eq 'HASH' );

    if ( $type ne '' ) { return $self->{numservices}{$type}; }
    else {
        my $total = 0;
        for ( values %{ $self->{numservices} } ) { $total += $_; }
        return $total;
    }          #(else) total number of services together
}

sub scan_types {
    return sort { $a cmp $b } ( keys %{ $_[0]->{type} } )
      if ( ref( $_[0]->{type} ) eq 'HASH' );
}
sub scan_type_proto { return $_[1] ? $_[0]->{type}{ $_[1] } : undef; }

sub prescripts {
    my $self = shift;
    my $id = shift;
    unless ( defined $id ) {
        return sort keys %{ $self->{prescript} };
    }
    else {
        return $self->{prescript}{$id};
    }
}

sub postscripts {
    my $self = shift;
    my $id = shift;
    unless ( defined $id ) {
        return sort keys %{ $self->{postscript} };
    }
    else {
        return $self->{postscript}{$id};
    }
}

#/*****************************************************************************/
# NMAP::PARSER::HOST
#/*****************************************************************************/

package Nmap::Parser::Host;
use vars qw($AUTOLOAD);

sub new {
    my $class = shift;
    $class = ref($class) || $class;
    my $self = shift || {};
    bless( $self, $class );
    return $self;
}

sub status { return $_[0]->{status}; }

sub addr {
    my $default = $_[0]->{addrs}{ipv4} || $_[0]->{addrs}{ipv6};
    return $default;
}

sub addrtype {
    if    ( $_[0]->{addrs}{ipv4} ) { return 'ipv4'; }
    elsif ( $_[0]->{addrs}{ipv6} ) { return 'ipv6'; }
}

sub ipv4_addr { return $_[0]->{addrs}{ipv4}; }
sub ipv6_addr { return $_[0]->{addrs}{ipv6}; }

sub mac_addr   { return $_[0]->{addrs}{mac}{addr}; }
sub mac_vendor { return $_[0]->{addrs}{mac}{vendor}; }

#returns the first hostname
sub hostname {
    my $self = shift;
    my $index = shift || 0;
    if ( ref( $self->{hostnames} ) ne 'ARRAY' ) { return ''; }
    if ( scalar @{ $self->{hostnames} } <= $index ) {
        $index = scalar @{ $self->{hostnames} } - 1;
    }
    return $self->{hostnames}[$index] if ( scalar @{ $self->{hostnames} } );
}

sub all_hostnames    { return @{ $_[0]->{hostnames} || [] }; }
sub extraports_state { return $_[0]->{ports}{extraports}{state}; }
sub extraports_count { return $_[0]->{ports}{extraports}{count}; }
sub distance         { return $_[0]->{distance}; }

sub hostscripts {
    my $self = shift;
    my $id = shift;
    unless ( defined $id ) {
        return sort keys %{ $self->{hostscript} };
    }
    else {
        return $self->{hostscript}{$id};
    }
}

sub all_trace_hops {

    my $self = shift;

    return unless defined $self->{trace}->{hops};
    return map { Nmap::Parser::Host::TraceHop->new( $_ ) }
      @{ $self->{trace}->{hops} };
}

sub trace_port  { return $_[0]->{trace}->{port} }
sub trace_proto { return $_[0]->{trace}->{proto} }
sub trace_error { return $_[0]->{trace_error} }

sub _del_port {
    my $self    = shift;
    my $proto   = pop;     #portid might be empty, so this goes first
    my @portids = @_;
    @portids = grep { $_ + 0 } @portids;

    unless ( scalar @portids ) {
        warn "[Nmap-Parser] No port number given to del_port()\n";
        return undef;
    }

    delete $self->{ports}{$proto}{$_} for (@portids);
}

sub _get_ports {
    my $self          = shift;
    my $proto         = pop;          #param might be empty, so this goes first
    my $state         = shift;    #open, filtered, closed or any combination
    my @matched_ports = ();

    #if $state is undef, then tcp_ports or udp_ports was called for all ports
    #therefore, only return the keys of all ports found
    if ( not defined $state ) {
        return sort { $a <=> $b } ( keys %{ $self->{ports}{$proto} } );
    }
    else {
        $state = lc($state)
    }

#the port parameter can be set to either any of these also 'open|filtered'
#can count as 'open' and 'filetered'. Therefore I need to use a regex from now on
#if $param is empty, then all ports match.

    for my $portid ( keys %{ $self->{ports}{$proto} } ) {

        #escape metacharacters ('|', for example in: open|filtered)
        #using \Q and \E
        push( @matched_ports, $portid )
          if ( $self->{ports}{$proto}{$portid}{state} =~ /\Q$state\E/ );

    }

    return sort { $a <=> $b } @matched_ports;

}

sub _get_port_state {
    my $self   = shift;
    my $proto  = pop;         #portid might be empty, so this goes first
    my $portid = lc(shift);

    return undef unless ( exists $self->{ports}{$proto}{$portid} );
    return $self->{ports}{$proto}{$portid}{state};

}

sub _get_port_state_ttl {
    my $self = shift;
    my $proto = pop;
    my $portid = lc(shift);

    return undef unless ( exists $self->{ports}{$proto}{$portid} );
    return $self->{ports}{$proto}{$portid}{reason_ttl};
}

#changed this to use _get_ports since it was similar code
sub tcp_ports { return _get_ports( @_, 'tcp' ); }
sub udp_ports { return _get_ports( @_, 'udp' ); }

sub tcp_port_count { return $_[0]->{ports}{tcp_port_count}; }
sub udp_port_count { return $_[0]->{ports}{udp_port_count}; }

sub tcp_port_state_ttl { return _get_port_state_ttl( @_, 'tcp' ); }

sub tcp_port_state { return _get_port_state( @_, 'tcp' ); }
sub udp_port_state { return _get_port_state( @_, 'udp' ); }

sub tcp_del_ports { return _del_port( @_, 'tcp' ); }
sub udp_del_ports { return _del_port( @_, 'udp' ); }

sub tcp_service {
    my $self   = shift;
    my $portid = shift;
    if ( $portid eq '' ) {
        warn "[Nmap-Parser] No port number passed to tcp_service()\n";
        return undef;
    }
    return Nmap::Parser::Host::Service->new(
        $self->{ports}{tcp}{$portid}{service} );
}

sub udp_service {
    my $self   = shift;
    my $portid = shift;
    if ( $portid eq '' ) {
        warn "[Nmap-Parser] No port number passed to udp_service()\n";
        return undef;
    }
    return Nmap::Parser::Host::Service->new(
        $self->{ports}{udp}{$portid}{service} );

}

#usually the first one is the highest accuracy

sub os_sig { return Nmap::Parser::Host::OS->new( $_[0]->{os} ); }

#Support for:
#tcpsequence_class, tcpsequence_values, tcpsequence_index,
#ipidsequence_class, ipidsequence_values, tcptssequence_values,
#tcptssequence_class, uptime_seconds, uptime_lastboot
#tcp_open_ports, udp_open_ports, tcp_filtered_ports, udp_filtered_ports,
#tcp_closed_ports, udp_closed_ports
sub AUTOLOAD {
    ( my $param = $AUTOLOAD ) =~ s{.*::}{}xms;
    return if ( $param eq 'DESTROY' );
    my ( $type, $val ) = split /_/, lc($param);

#splits the given method name by '_'. This will determine the function and param
    no strict 'refs';

    if (   ( $type eq 'tcp' || $type eq 'udp' )
        && ( $val eq 'open' || $val eq 'filtered' || $val eq 'closed' ) )
    {

#they must be looking for port info: tcp or udp. The $val is either open|filtered|closed
        *$AUTOLOAD = sub { return _get_ports( $_[0], $val, $type ); };
        goto &$AUTOLOAD;

    }
    elsif ( defined $type && defined $val ) {

        #must be one of the 'sequence' functions asking for class/values/index
        *$AUTOLOAD = sub { return $_[0]->{$type}{$val} };
        goto &$AUTOLOAD;
    }
    else { die '[Nmap-Parser] method ->' . $param . "() not defined!\n"; }
}

#/*****************************************************************************/
# NMAP::PARSER::HOST::SERVICE
#/*****************************************************************************/

package Nmap::Parser::Host::Service;
use vars qw($AUTOLOAD);

sub new {
    my $class = shift;
    $class = ref($class) || $class;
    my $self = shift || {};
    bless( $self, $class );
    return $self;
}

sub scripts {
    my $self = shift;
    my $id = shift;

    unless ( defined $id ) {
        return sort keys %{ $self->{script} };
    }
    else {
        return $self->{script}{$id};
    }
}

#Support for:
#name port proto rpcnum owner version product extrainfo tunnel method confidence
#this will now only load functions that will be used. This saves
#on delay (increase speed) and memory

sub AUTOLOAD {
    ( my $param = $AUTOLOAD ) =~ s{.*::}{}xms;
    return if ( $param eq 'DESTROY' );
    no strict 'refs';

    *$AUTOLOAD = sub { return $_[0]->{ lc $param } };
    goto &$AUTOLOAD;
}

#/*****************************************************************************/
# NMAP::PARSER::HOST::OS
#/*****************************************************************************/

package Nmap::Parser::Host::OS;
use vars qw($AUTOLOAD);

sub new {
    my $class = shift;
    $class = ref($class) || $class;
    my $self = shift || {};
    bless( $self, $class );
    return $self;
}

sub portused_open   { return $_[0]->{portused}{open}; }
sub portused_closed { return $_[0]->{portused}{closed}; }
sub os_fingerprint  { return $_[0]->{os_fingerprint}; }

sub name_count { return $_[0]->{osmatch_count}; }

sub all_names {
    my $self = shift;
    @_ = ();
    if ( $self->{osclass_count} < 1 ) { return @_; }
    if ( ref( $self->{osmatch_name} ) eq 'ARRAY' ) {
        return sort @{ $self->{osmatch_name} };
    }

}    #given by decreasing accuracy

sub class_count { return $_[0]->{osclass_count}; }

#Support for:
#name,names, name_accuracy, osfamily, vendor, type, osgen, class_accuracy
sub AUTOLOAD {
    ( my $param = $AUTOLOAD ) =~ s{.*::}{}xms;
    return if ( $param eq 'DESTROY' );
    no strict 'refs';
    $param = lc($param);

    $param = 'name' if ( $param eq 'names' );
    if ( $param eq 'name' || $param eq 'name_accuracy' ) {

        *$AUTOLOAD = sub { _get_info( $_[0], $_[1], $param, 'osmatch' ); };
        goto &$AUTOLOAD;
    }
    else {

        *$AUTOLOAD = sub { _get_info( $_[0], $_[1], $param, 'osclass' ); };
        goto &$AUTOLOAD;
    }
}

sub _get_info {
    my ( $self, $index, $param, $type ) = @_;
    $index ||= 0;

    #type is either osclass or osmatch
    if ( $index >= $self->{ $type . '_count' } ) {
        $index = $self->{ $type . '_count' } - 1;
    }
    return $self->{ $type . '_' . $param }[$index];
}

#/*****************************************************************************/
# NMAP::PARSER::HOST::TRACEHOP
#/*****************************************************************************/

package Nmap::Parser::Host::TraceHop;
use vars qw($AUTOLOAD);

sub new {
    my $class = shift;
    $class = ref($class) || $class;
    my $self = shift || {};
    bless( $self, $class );
    return $self;
}

sub AUTOLOAD {
    ( my $param = $AUTOLOAD ) =~ s{.*::}{}xms;
    return if ( $param eq 'DESTROY' );
    no strict 'refs';
    $param = lc($param);

    # Supported accessors:
    my %subs;
    @subs{ qw( ttl rtt ipaddr host ) } = 1;

    if ( exists $subs{$param} ) {

        *$AUTOLOAD = sub { $_[0]->{$param} };
        goto &$AUTOLOAD;
    }
    else { die '[Nmap-Parser] method ->' . $param . "() not defined!\n"; }
}

1;

__END__