File Coverage

blib/lib/Net/Whois/Gateway/Client.pm

Criterion	Covered	Total	%
statement	9	83	10.8
branch	0	32	0.0
condition	0	38	0.0
subroutine	3	13	23.0
pod	1	5	20.0
total	13	171	7.6

package Net::Whois::Gateway::Client;

use strict;
#use Data::Dumper;
use Carp;
use IO::Socket::INET;

require bytes;
require Storable;

our $VERSION = 0.12;
our $DEBUG = 0;

our $online;

our %POSTPROCESS;
our $default_host = "localhost";
our $default_port = 54321;
our @answer;


our $configuration;

our %SOCKET_FACTORY;

# get whois info from gateway
# %param: queries*, gateway_host, gateway_post, timeout, ?????
sub whois {
    my %param = @_;

    exists $param{query}
	or die "No query given";

    my @answer = _send_request( %param );

    return apply_postprocess(@answer);
}

sub _send_request {
    my %param = @_;

    my $timeout = $param{timeout} || 30;
    my $buffer;

    local $SIG{__DIE__} = sub {
	$online = 0;
	die @_;
    };

    my $resp;

    foreach my $critical (0..1) {
	$resp = eval {
	    local $SIG{ALRM} = sub { warn "timeout\n"; die "timeout\n" }   if $timeout;
	    alarm $timeout*1.2 				 if $timeout;

	    my ($socket, $new_socket) = _get_socket( \%param );
		$socket or die "WHOIS: cannot open socket: $!";

        if ( $new_socket && $configuration ) {
            # repeat configuration as not critical one
            ping( default_config => $configuration );
        }

	    #use Data::Dumper;
	    #warn Dumper $socket;

#	    $socket->connected
#		or die "WHOIS: socket is not connected";

	    my $frozen = Storable::nfreeze( [ \%param ] );
	    $frozen = bytes::length( $frozen ). "\0" . $frozen;

	    my $w = $socket->syswrite( $frozen, bytes::length( $frozen ) );

	    if ( ! defined $w || $w <= 0 ) {
		die "WHOIS: Cannot syswrite to socket: $!";
	    }

	    my $r = $socket->sysread( $buffer, 65536 );

	    if ( ! defined $r || $r <= 0 ) {
		die "WHOIS: Cannot sysread from socket: $!";
	    }

        return 1;
	};

	if ( $@ ) {
	    _fail_socket( \%param );
	    warn $@ if ! $critical && $@ ne "timeout\n";
	}

	last if $resp;
    }

    alarm 0 if $timeout;

    if ( $@ ) {
	if ( $@ eq "timeout\n" ) {
	    die "WHOIS: timeout calling sysread/syswrite";
	}
	else {
	    die $@;
	}
    }

    my $answer;

    if (
	$buffer &&
	$buffer =~ /^(\d+)\0/o &&
	bytes::length( $buffer ) >= $1 + bytes::length($1) + 1
    ) {
	$answer = Storable::thaw( substr( $buffer, bytes::length($1) + 1, $1 ) );
    }
    else {
	die "WHOIS: Cannot parse BUFFER";
    }

    return @$answer;
}

sub _fail_socket {
    my $param_ref = shift;

    my $gateway_host = $param_ref->{gateway_host} || $default_host;
    my $gateway_port = $param_ref->{gateway_port} || $default_port;

    my $addr = $gateway_host.':'.$gateway_port;

    delete $SOCKET_FACTORY{ $addr };
}

sub _get_socket {
    my $param_ref = shift;

    my $gateway_host = $param_ref->{gateway_host} || $default_host;
    my $gateway_port = $param_ref->{gateway_port} || $default_port;

    my $addr = $gateway_host.':'.$gateway_port;

#    use Data::Dumper;
#    warn Dumper \%SOCKET_FACTORY;

    #warn $SOCKET_FACTORY{$addr} && $SOCKET_FACTORY{$addr}->connected;

    return ($SOCKET_FACTORY{ $addr }, 0) if	 $SOCKET_FACTORY{ $addr }
				      && $SOCKET_FACTORY{ $addr }->connected;

    #warn "reconnection $addr";
    $SOCKET_FACTORY{ $addr } = IO::Socket::INET->new( $addr );

    return ($SOCKET_FACTORY{ $addr }, 1);
}

sub close_sockets {
    $_->close() foreach values %SOCKET_FACTORY;
    %SOCKET_FACTORY = ();
}

sub configure {
    my $new_config = shift;
    $configuration = $new_config;
}

sub ping {
    my %params = (ping => 1, @_);
    my $res;
    $online = 1;
    eval {
        ($res) = _send_request(%params);
    };
    return $res;
}

sub apply_postprocess {
    my @all_results = @_;
    my @out_results;

    foreach my $result ( @all_results ) {
        my $server = $result->{server};
        if ($result->{whois} && defined $POSTPROCESS{$server}) {
            $result->{whois} = $POSTPROCESS{$server}->($result->{whois});
        }
        push @out_results, $result;
    }

    return @out_results;
}

1;
__END__