File Coverage

blib/lib/IO/Stream/Proxy/SOCKSv5.pm

Criterion	Covered	Total	%
statement	62	125	49.6
branch	0	38	0.0
condition	0	9	0.0
subroutine	21	26	80.7
pod	1	3	33.3
total	84	201	41.7

package IO::Stream::Proxy::SOCKSv5;
use 5.010001;
use warnings;
use strict;
use utf8;
use Carp;

our $VERSION = 'v2.0.1';

use IO::Stream::const;
use IO::Stream::EV;
use Scalar::Util qw( weaken );

use constant HANDSHAKE      => 1;
use constant CONNECTING     => 2;

                                    ### SOCKS protocol constants:
use constant VN             => 0x05;# version number (5)
use constant AUTH_NO        => 0x00;# authentication method id
use constant CD             => 0x01;# command code (CONNECT)
## no critic (Capitalization)
use constant ADDR_IPv4      => 0x01;# address type (IPv4)
use constant ADDR_DOMAIN    => 0x03;# address type (DOMAIN)
use constant ADDR_IPv6      => 0x04;# address type (IPv6)
use constant LEN_IPv4       => 4;
use constant LEN_IPv6       => 16;
## use critic
use constant REPLY_LEN_HANDSHAKE=> 2; # reply length for handshake (bytes)
use constant REPLY_LEN_CONNECT  => 4; # reply length for connect header (bytes)
use constant REPLY_CD       => 0x00;# reply code 'request granted'


sub new {
    my ($class, $opt) = @_;
    croak '{host}+{port} required'
        if !defined $opt->{host}
        || !defined $opt->{port}
        ;
    my $self = bless {
        host        => undef,
        port        => undef,
#        user        => q{},    # TODO
#        pass        => q{},    # TODO
        %{$opt},
        out_buf     => q{},                 # modified on: OUT
        out_pos     => undef,               # modified on: OUT
        out_bytes   => 0,                   # modified on: OUT
        in_buf      => q{},                 # modified on: IN
        in_bytes    => 0,                   # modified on: IN
        ip          => undef,               # modified on: RESOLVED
        is_eof      => undef,               # modified on: EOF
        _want_write => undef,
        _state      => 0,                   # HANDSHAKE -> [AUTH] -> CONNECTING
        _port       => undef,
        }, $class;
    return $self;
}

sub PREPARE {
    my ($self, $fh, $host, $port) = @_;
    croak '{fh} already connected'
        if !defined $host;
    $self->{_port} = $port;
    $self->{_slave}->PREPARE($fh, $self->{host}, $self->{port});
    IO::Stream::EV::resolve($host, $self, sub {
        my ($self, $ip) = @_;
        $self->{_master}{ip} = $ip;
        $self->{_state} = HANDSHAKE;
        my @auth = ( AUTH_NO );
        $self->{out_buf} = pack 'C C C*', VN, 0+@auth, @auth;
        $self->{_slave}->WRITE();
    });
    return;
}

sub WRITE {
    my ($self) = @_;
    $self->{_want_write} = 1;
    return;
}

sub EVENT { ## no critic (ProhibitExcessComplexity)
    ## no critic (ProhibitDeepNests)
    my ($self, $e, $err) = @_;
    my $m = $self->{_master};
    if ($err) {
        $m->EVENT(0, $err);
    }
    if ($e & IN) {
        if ($self->{_state} == HANDSHAKE) {
            if (length $self->{in_buf} < REPLY_LEN_HANDSHAKE) {
                $m->EVENT(0, 'socks v5 proxy: protocol error');
            } else {
                my ($vn, $auth) = unpack 'CC', $self->{in_buf};
                substr $self->{in_buf}, 0, REPLY_LEN_HANDSHAKE, q{};
                if ($vn != VN) {
                    $m->EVENT(0, 'socks v5 proxy: unknown version of reply code');
                }
                elsif ($auth != AUTH_NO) {
                    $m->EVENT(0, 'socks v5 proxy: auth method handshake error');
                }
                else {
                    $self->{_state} = CONNECTING;
                    $self->{out_buf} = pack 'C C C C CCCC n',
                        VN, CD, 0, ADDR_IPv4,
                        split(/[.]/xms, $self->{_master}{ip}), $self->{_port};
                    $self->{_slave}->WRITE();
                }
            }
        }
        elsif ($self->{_state} == CONNECTING) {
            if (length $self->{in_buf} < REPLY_LEN_CONNECT) {
                $m->EVENT(0, 'socks v5 proxy: protocol error');
            } else {
                my ($vn, $cd, $atype) = unpack 'CCxC', $self->{in_buf};
                substr $self->{in_buf}, 0, REPLY_LEN_CONNECT, q{};
                if ($vn != VN) {
                    $m->EVENT(0, 'socks v5 proxy: unknown version of reply code');
                }
                elsif ($cd != REPLY_CD) {
                    $m->EVENT(0, 'socks v5 proxy: error '.$cd);
                }
                elsif ($atype != ADDR_IPv4 && $atype != ADDR_DOMAIN && $atype != ADDR_IPv6) {
                    $m->EVENT(0, 'socks v5 proxy: unknown address type '.$atype);
                }
                else {
                    my $tail_len
                        = $atype == ADDR_IPv4   ? LEN_IPv4+2
                        : $atype == ADDR_DOMAIN ? 1+unpack('C', $self->{in_buf})+2
                        :                         LEN_IPv6+2
                        ;
                    if (length $self->{in_buf} < $tail_len) {
                        $m->EVENT(0, 'socks v5 proxy: protocol error');
                    } else {
                        substr $self->{in_buf}, 0, $tail_len, q{};
                        # SOCKS v5 protocol done
                        $e = CONNECTED;
                        if (my $l = length $self->{in_buf}) {
                            $e |= IN;
                            $m->{in_buf}    .= $self->{in_buf};
                            $m->{in_bytes}  += $l;
                        }
                        $m->EVENT($e);
                        $self->{_slave}->{_master} = $m;
                        weaken($self->{_slave}->{_master});
                        $m->{_slave} = $self->{_slave};
                        if ($self->{_want_write}) {
                            $self->{_slave}->WRITE();
                        }
                    }
                }
            }
        }
    }
    if ($e & EOF) {
        $m->{is_eof} = $self->{is_eof};
        $m->EVENT(0, 'socks v5 proxy: unexpected EOF');
    }
    return;
}


1; # Magic true value required at end of module
__END__