File Coverage

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

Criterion	Covered	Total	%
statement	26	68	38.2
branch	0	22	0.0
condition	0	7	0.0
subroutine	9	13	69.2
pod	1	3	33.3
total	36	113	31.8

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

our $VERSION = 'v2.0.1';

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

use constant HTTP_OK => 200;

sub new {
    my ($class, $opt) = @_;
    croak '{host}+{port} required'
        if !defined $opt->{host}
        || !defined $opt->{port}
        ;
    croak '{user}+{pass} required'
        if $opt->{user} xor $opt->{pass};
    my $self = bless {
        host        => undef,
        port        => undef,
        user        => undef,
        pass        => undef,
        %{$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,
        }, $class;
    return $self;
}

sub PREPARE {
    my ($self, $fh, $host, $port) = @_;
    croak '{fh} already connected'
        if !defined $host;
    $self->{out_buf} = "CONNECT ${host}:${port} HTTP/1.0\r\n";
    if (defined $self->{user}) {
        $self->{out_buf} .= 'Proxy-Authorization: Basic '
            . encode_base64($self->{user}.q{:}.$self->{pass}, q{})
            . "\r\n"
            ;
    }
    $self->{out_buf} .= "\r\n";
    $self->{_slave}->PREPARE($fh, $self->{host}, $self->{port});
    $self->{_slave}->WRITE();
    return;
}

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

sub EVENT {
    my ($self, $e, $err) = @_;
    my $m = $self->{_master};
    if ($err) {
        $m->EVENT(0, $err);
    }
    if ($e & IN) {
        if ($self->{in_buf} =~ s{\A(HTTP/\d[.]\d\s(\d+)\s.*?)\r?\n\r?\n}{}xms) {
            my ($reply, $status) = ($1, $2);
            if ($status == HTTP_OK) {
                $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();
                }
            }
            else {
                $m->EVENT(0, 'https proxy: '.$reply);
            }
        }
    }
    if ($e & EOF) {
        $m->{is_eof} = $self->{is_eof};
        $m->EVENT(0, 'https proxy: unexpected EOF');
    }
    return;
}


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