view release on metacpan or  search on metacpan

lib/HTTP/Tiny/SPDY.pm  view on Meta::CPAN

            my $data_cb = $self->_prepare_data_cb($response, $args);
            $known_message_length = $handle->read_body($data_cb, $response);
        }

        if ( $self->{keep_alive}
            && $known_message_length
            && $response->{protocol} eq 'HTTP/1.1'
            && ($response->{headers}{connection} || '') ne 'close'
        ) {
            $self->{handle} = $handle;
        }
        else {
            $handle->close;
        }        
    }
 
    $response->{success} = substr($response->{status},0,1) eq '2';
    $response->{url} = $url;
    return $response;
}

sub _open_handle {
    my ($self, $request, $scheme, $host, $port) = @_;

    if ($self->{enable_SPDY}) {
        my $handle  = HTTP::Tiny::Handle::SPDY->new(
            timeout         => $self->{timeout},
            SSL_options     => $self->{SSL_options},
            verify_SSL      => $self->{verify_SSL},
            local_address   => $self->{local_address},
            keep_alive      => $self->{keep_alive},
        );

        if ($self->{_has_proxy}{$scheme} && ! grep { $host =~ /\Q$_\E$/ } @{$self->{no_proxy}}) {
            return $self->_proxy_connect( $request, $handle );
        }
        else {
            return $handle->connect($scheme, $host, $port);
        }
    }
    else {
        return $self->SUPER::_open_handle($request, $scheme, $host, $port);
    }
}

package
    HTTP::Tiny::Handle::SPDY;

use strict;
use warnings;

use IO::Socket qw(SOCK_STREAM);

use parent -norequire, 'HTTP::Tiny::Handle';

sub connect {
    @_ == 4 || die(q/Usage: $handle->connect(scheme, host, port)/ . "\n");
    my ($self, $scheme, $host, $port) = @_;
 
    if ( $scheme eq 'https' ) {
        # Need IO::Socket::SSL 1.42 for SSL_create_ctx_callback
        die(qq/IO::Socket::SSL 1.42 must be installed for https support\n/)
            unless eval {require IO::Socket::SSL; IO::Socket::SSL->VERSION(1.42)};
        # Need Net::SSLeay 1.49 for MODE_AUTO_RETRY
        die(qq/Net::SSLeay 1.49 must be installed for https support\n/)
            unless eval {require Net::SSLeay; Net::SSLeay->VERSION(1.49)};
    }
    elsif ( $scheme ne 'http' ) {
      die(qq/Unsupported URL scheme '$scheme'\n/);
    }
    $self->{fh} = 'IO::Socket::INET'->new(
        PeerHost  => $host,
        PeerPort  => $port,
        $self->{local_address} ?
            ( LocalAddr => $self->{local_address} ) : (),
        Proto     => 'tcp',
        Type      => SOCK_STREAM,
        Timeout   => $self->{timeout}
    ) or die(qq/Could not connect to '$host:$port': $@\n/);
 
    binmode($self->{fh})
      or die(qq/Could not binmode() socket: '$!'\n/);

    if ($scheme eq 'https') {
        $self->start_ssl($host);

        if ($self->{fh}->next_proto_negotiated &&
            $self->{fh}->next_proto_negotiated eq 'spdy/3')
        {
            # SPDY negotiation succeeded
            $self->{spdy} = {
                session => Net::SPDY::Session->new($self->{fh}),
                stream_id => 1,
            };
        }
    }

    $self->{scheme} = $scheme;
    $self->{host} = $host;
    $self->{port} = $port;
 
    return $self;
}

my $Printable = sub {
    local $_ = shift;
    s/\r/\\r/g;
    s/\n/\\n/g;
    s/\t/\\t/g;
    s/([^\x20-\x7E])/sprintf('\\x%.2X', ord($1))/ge;
    $_;
};

# HTTP headers which must not be present in a SPDY request
my %invalid_headers;
undef @invalid_headers{qw( connection host )};
 
sub write_request {
    @_ == 2 || die(q/Usage: $handle->write_request(request)/ . "\n");
    my ($self, $request) = @_;

    if (defined $self->{spdy}) {
        my $framer = $self->{spdy}->{session}->{framer};