ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/AnyEvent-HTTP/HTTP.pm
(Generate patch)

Comparing AnyEvent-HTTP/HTTP.pm (file contents):
Revision 1.81 by root, Sun Jan 2 01:20:17 2011 UTC vs.
Revision 1.89 by root, Mon Jan 3 00:23:25 2011 UTC

… …
36 36
37=cut 37=cut
38 38
39package AnyEvent::HTTP; 39package AnyEvent::HTTP;
40 40
41use strict; 41use common::sense;
42no warnings;
43 42
44use Errno (); 43use Errno ();
45 44
46use AnyEvent 5.0 (); 45use AnyEvent 5.0 ();
47use AnyEvent::Util (); 46use AnyEvent::Util ();
… …
58our $MAX_PERSISTENT = 8; 57our $MAX_PERSISTENT = 8;
59our $PERSISTENT_TIMEOUT = 2; 58our $PERSISTENT_TIMEOUT = 2;
60our $TIMEOUT = 300; 59our $TIMEOUT = 300;
61 60
62# changing these is evil 61# changing these is evil
63our $MAX_PERSISTENT_PER_HOST = 0; 62our $MAX_PERSISTENT_PER_HOST = 2;
64our $MAX_PER_HOST = 4; 63our $MAX_PER_HOST = 4;
65 64
66our $PROXY; 65our $PROXY;
67our $ACTIVE = 0; 66our $ACTIVE = 0;
68 67
… …
475 while ( 474 while (
476 m{ 475 m{
477 \G\s* 476 \G\s*
478 (?: 477 (?:
479 expires \s*=\s* ([A-Z][a-z][a-z]+,\ [^,;]+) 478 expires \s*=\s* ([A-Z][a-z][a-z]+,\ [^,;]+)
480 | ([^=;,[:space:]]+) \s*=\s* (?: "((?:[^\\"]+|\\.)*)" | ([^=;,[:space:]]*) ) 479 | ([^=;,[:space:]]+) (?: \s*=\s* (?: "((?:[^\\"]+|\\.)*)" | ([^=;,[:space:]]*) ) )?
481 ) 480 )
482 }gcxsi 481 }gcxsi
483 ) { 482 ) {
484 my $name = $2; 483 my $name = $2;
485 my $value = $4; 484 my $value = $4;
486 485
487 unless (defined $name) { 486 if (defined $1) {
488 # expires 487 # expires
489 $name = "expires"; 488 $name = "expires";
490 $value = $1; 489 $value = $1;
491 } elsif (!defined $value) { 490 } elsif (defined $3) {
492 # quoted 491 # quoted
493 $value = $3; 492 $value = $3;
494 $value =~ s/\\(.)/$1/gs; 493 $value =~ s/\\(.)/$1/gs;
495 } 494 }
496 495
… …
530 $cdom = $uhost; 529 $cdom = $uhost;
531 } 530 }
532 531
533 # store it 532 # store it
534 $jar->{version} = 1; 533 $jar->{version} = 1;
535 $jar->{$cdom}{$cpath}{$name} = \%kv; 534 $jar->{lc $cdom}{$cpath}{$name} = \%kv;
536 535
537 redo if /\G\s*,/gc; 536 redo if /\G\s*,/gc;
538 } 537 }
539} 538}
540 539
… …
607 : return $cb->(undef, { @pseudo, Status => 599, Reason => "Only http and https URL schemes supported" }); 606 : return $cb->(undef, { @pseudo, Status => 599, Reason => "Only http and https URL schemes supported" });
608 607
609 $uauthority =~ /^(?: .*\@ )? ([^\@:]+) (?: : (\d+) )?$/x 608 $uauthority =~ /^(?: .*\@ )? ([^\@:]+) (?: : (\d+) )?$/x
610 or return $cb->(undef, { @pseudo, Status => 599, Reason => "Unparsable URL" }); 609 or return $cb->(undef, { @pseudo, Status => 599, Reason => "Unparsable URL" });
611 610
612 my $uhost = $1; 611 my $uhost = lc $1;
613 $uport = $2 if defined $2; 612 $uport = $2 if defined $2;
614 613
615 $hdr{host} = defined $2 ? "$uhost:$2" : "$uhost" 614 $hdr{host} = defined $2 ? "$uhost:$2" : "$uhost"
616 unless exists $hdr{host}; 615 unless exists $hdr{host};
617 616
… …
636 $rscheme = "http" unless defined $rscheme; 635 $rscheme = "http" unless defined $rscheme;
637 636
638 # don't support https requests over https-proxy transport, 637 # don't support https requests over https-proxy transport,
639 # can't be done with tls as spec'ed, unless you double-encrypt. 638 # can't be done with tls as spec'ed, unless you double-encrypt.
640 $rscheme = "http" if $uscheme eq "https" && $rscheme eq "https"; 639 $rscheme = "http" if $uscheme eq "https" && $rscheme eq "https";
640
641 $rhost = lc $rhost;
642 $rscheme = lc $rscheme;
641 } else { 643 } else {
642 ($rhost, $rport, $rscheme, $rpath) = ($uhost, $uport, $uscheme, $upath); 644 ($rhost, $rport, $rscheme, $rpath) = ($uhost, $uport, $uscheme, $upath);
643 } 645 }
644 646
645 # leave out fragment and query string, just a heuristic 647 # leave out fragment and query string, just a heuristic
… …
647 $hdr{"user-agent"} = $USERAGENT unless exists $hdr{"user-agent"}; 649 $hdr{"user-agent"} = $USERAGENT unless exists $hdr{"user-agent"};
648 650
649 $hdr{"content-length"} = length $arg{body} 651 $hdr{"content-length"} = length $arg{body}
650 if length $arg{body} || $method ne "GET"; 652 if length $arg{body} || $method ne "GET";
651 653
652 $hdr{connection} = "close TE"; #1.1 654 my $idempotent = $method =~ /^(?:GET|HEAD|PUT|DELETE|OPTIONS|TRACE)$/;
655
656 # default value for keepalive is true iff the request is for an idempotent method
657 my $keepalive = exists $arg{keepalive}
658 ? $arg{keepalive}*1
659 : $idempotent ? $PERSISTENT_TIMEOUT : 0;
660
661 $hdr{connection} = ($keepalive ? "" : "close ") . "Te"; #1.1
653 $hdr{te} = "trailers" unless exists $hdr{te}; #1.1 662 $hdr{te} = "trailers" unless exists $hdr{te}; #1.1
654 663
655 my %state = (connect_guard => 1); 664 my %state = (connect_guard => 1);
656 665
657 _get_slot $uhost, sub {
658 $state{slot_guard} = shift;
659
660 return unless $state{connect_guard};
661
662 my $ae_error = 595; # connecting 666 my $ae_error = 595; # connecting
663 667
664 my $connect_cb = sub { 668 # handle actual, non-tunneled, request
665 $state{fh} = shift 669 my $handle_actual_request = sub {
670 $ae_error = 596; # request phase
671
672 $state{handle}->starttls ("connect") if $uscheme eq "https" && !exists $state{handle}{tls};
673
674 # send request
675 $state{handle}->push_write (
676 "$method $rpath HTTP/1.1\015\012"
677 . (join "", map "\u$_: $hdr{$_}\015\012", grep defined $hdr{$_}, keys %hdr)
678 . "\015\012"
679 . (delete $arg{body})
680 );
681
682 # return if error occured during push_write()
683 return unless %state;
684
685 # reduce memory usage, save a kitten, also re-use it for the response headers.
686 %hdr = ();
687
688 # status line and headers
689 $state{read_response} = sub {
690 for ("$_[1]") {
691 y/\015//d; # weed out any \015, as they show up in the weirdest of places.
692
693 /^HTTP\/0*([0-9\.]+) \s+ ([0-9]{3}) (?: \s+ ([^\012]*) )? \012/gxci
694 or return (%state = (), $cb->(undef, { @pseudo, Status => 599, Reason => "Invalid server response" }));
695
696 # 100 Continue handling
697 # should not happen as we don't send expect: 100-continue,
698 # but we handle it just in case.
699 # since we send the request body regardless, if we get an error
700 # we are out of-sync, which we currently do NOT handle correctly.
701 return $state{handle}->push_read (line => $qr_nlnl, $state{read_response})
702 if $2 eq 100;
703
704 push @pseudo,
705 HTTPVersion => $1,
706 Status => $2,
707 Reason => $3,
666 or do { 708 ;
667 my $err = "$!"; 709
710 my $hdr = parse_hdr
711 or return (%state = (), $cb->(undef, { @pseudo, Status => 599, Reason => "Garbled response headers" }));
712
713 %hdr = (%$hdr, @pseudo);
714 }
715
716 # redirect handling
717 # microsoft and other shitheads don't give a shit for following standards,
718 # try to support some common forms of broken Location headers.
719 if ($hdr{location} !~ /^(?: $ | [^:\/?\#]+ : )/x) {
720 $hdr{location} =~ s/^\.\/+//;
721
722 my $url = "$rscheme://$uhost:$uport";
723
724 unless ($hdr{location} =~ s/^\///) {
725 $url .= $upath;
726 $url =~ s/\/[^\/]*$//;
727 }
728
729 $hdr{location} = "$url/$hdr{location}";
730 }
731
732 my $redirect;
733
734 if ($recurse) {
735 my $status = $hdr{Status};
736
737 # industry standard is to redirect POST as GET for
738 # 301, 302 and 303, in contrast to HTTP/1.0 and 1.1.
739 # also, the UA should ask the user for 301 and 307 and POST,
740 # industry standard seems to be to simply follow.
741 # we go with the industry standard.
742 if ($status == 301 or $status == 302 or $status == 303) {
743 # HTTP/1.1 is unclear on how to mutate the method
744 $method = "GET" unless $method eq "HEAD";
745 $redirect = 1;
746 } elsif ($status == 307) {
747 $redirect = 1;
748 }
749 }
750
751 my $finish = sub { # ($data, $err_status, $err_reason[, $keepalive])
752 my $may_keep_alive = $_[3];
753
754 $state{handle}->destroy if $state{handle};
668 %state = (); 755 %state = ();
669 return $cb->(undef, { @pseudo, Status => $ae_error, Reason => $err }); 756
757 if (defined $_[1]) {
758 $hdr{OrigStatus} = $hdr{Status}; $hdr{Status} = $_[1];
759 $hdr{OrigReason} = $hdr{Reason}; $hdr{Reason} = $_[2];
760 }
761
762 # set-cookie processing
763 if ($arg{cookie_jar}) {
764 cookie_jar_set_cookie $arg{cookie_jar}, $hdr{"set-cookie"}, $uhost, $hdr{date};
765 }
766
767 if ($redirect && exists $hdr{location}) {
768 # we ignore any errors, as it is very common to receive
769 # Content-Length != 0 but no actual body
770 # we also access %hdr, as $_[1] might be an erro
771 http_request (
772 $method => $hdr{location},
773 %arg,
774 recurse => $recurse - 1,
775 Redirect => [$_[0], \%hdr],
776 $cb);
777 } else {
778 $cb->($_[0], \%hdr);
779 }
780 };
781
782 $ae_error = 597; # body phase
783
784 my $len = $hdr{"content-length"};
785
786 # body handling, many different code paths
787 # - no body expected
788 # - want_body_handle
789 # - te chunked
790 # - 2x length known (with or without on_body)
791 # - 2x length not known (with or without on_body)
792 if (!$redirect && $arg{on_header} && !$arg{on_header}(\%hdr)) {
793 $finish->(undef, 598 => "Request cancelled by on_header");
794 } elsif (
795 $hdr{Status} =~ /^(?:1..|204|205|304)$/
796 or $method eq "HEAD"
797 or (defined $len && $len == 0) # == 0, not !, because "0 " is true
798 ) {
799 # no body
800 $finish->("", undef, undef, 1);
801
802 } elsif (!$redirect && $arg{want_body_handle}) {
803 $_[0]->on_eof (undef);
804 $_[0]->on_error (undef);
805 $_[0]->on_read (undef);
806
807 $finish->(delete $state{handle});
808
809 } elsif ($hdr{"transfer-encoding"} =~ /\bchunked\b/i) {
810 my $cl = 0;
811 my $body = undef;
812 my $on_body = $arg{on_body} || sub { $body .= shift; 1 };
813
814 $state{read_chunk} = sub {
815 $_[1] =~ /^([0-9a-fA-F]+)/
816 or $finish->(undef, $ae_error => "Garbled chunked transfer encoding");
817
818 my $len = hex $1;
819
820 if ($len) {
821 $cl += $len;
822
823 $_[0]->push_read (chunk => $len, sub {
824 $on_body->($_[1], \%hdr)
825 or return $finish->(undef, 598 => "Request cancelled by on_body");
826
827 $_[0]->push_read (line => sub {
828 length $_[1]
829 and return $finish->(undef, $ae_error => "Garbled chunked transfer encoding");
830 $_[0]->push_read (line => $state{read_chunk});
831 });
832 });
833 } else {
834 $hdr{"content-length"} ||= $cl;
835
836 $_[0]->push_read (line => $qr_nlnl, sub {
837 if (length $_[1]) {
838 for ("$_[1]") {
839 y/\015//d; # weed out any \015, as they show up in the weirdest of places.
840
841 my $hdr = parse_hdr
842 or return $finish->(undef, $ae_error => "Garbled response trailers");
843
844 %hdr = (%hdr, %$hdr);
845 }
846 }
847
848 $finish->($body, undef, undef, 1);
849 });
850 }
670 }; 851 };
671 852
853 $_[0]->push_read (line => $state{read_chunk});
854
855 } elsif ($arg{on_body}) {
856 if (defined $len) {
857 $_[0]->on_read (sub {
858 $len -= length $_[0]{rbuf};
859
860 $arg{on_body}(delete $_[0]{rbuf}, \%hdr)
861 or return $finish->(undef, 598 => "Request cancelled by on_body");
862
863 $len > 0
864 or $finish->("", undef, undef, 1);
865 });
866 } else {
867 $_[0]->on_eof (sub {
868 $finish->("");
869 });
870 $_[0]->on_read (sub {
871 $arg{on_body}(delete $_[0]{rbuf}, \%hdr)
872 or $finish->(undef, 598 => "Request cancelled by on_body");
873 });
874 }
875 } else {
876 $_[0]->on_eof (undef);
877
878 if (defined $len) {
879 $_[0]->on_read (sub {
880 $finish->((substr delete $_[0]{rbuf}, 0, $len, ""), undef, undef, 1)
881 if $len <= length $_[0]{rbuf};
882 });
883 } else {
884 $_[0]->on_error (sub {
885 ($! == Errno::EPIPE || !$!)
886 ? $finish->(delete $_[0]{rbuf})
887 : $finish->(undef, $ae_error => $_[2]);
888 });
889 $_[0]->on_read (sub { });
890 }
891 }
892 };
893
894 $state{handle}->push_read (line => $qr_nlnl, $state{read_response});
895 };
896
897 my $connect_cb = sub {
898 $state{fh} = shift
899 or do {
900 my $err = "$!";
901 %state = ();
902 return $cb->(undef, { @pseudo, Status => $ae_error, Reason => $err });
903 };
904
672 return unless delete $state{connect_guard}; 905 return unless delete $state{connect_guard};
673 906
674 # get handle 907 # get handle
675 $state{handle} = new AnyEvent::Handle 908 $state{handle} = new AnyEvent::Handle
676 fh => $state{fh}, 909 fh => $state{fh},
677 peername => $rhost, 910 peername => $rhost,
678 tls_ctx => $arg{tls_ctx}, 911 tls_ctx => $arg{tls_ctx},
679 # these need to be reconfigured on keepalive handles 912 # these need to be reconfigured on keepalive handles
680 timeout => $timeout, 913 timeout => $timeout,
681 on_error => sub { 914 on_error => sub {
682 %state = (); 915 %state = ();
683 $cb->(undef, { @pseudo, Status => $ae_error, Reason => $_[2] }); 916 $cb->(undef, { @pseudo, Status => $ae_error, Reason => $_[2] });
684 }, 917 },
685 on_eof => sub { 918 on_eof => sub {
686 %state = (); 919 %state = ();
687 $cb->(undef, { @pseudo, Status => $ae_error, Reason => "Unexpected end-of-file" }); 920 $cb->(undef, { @pseudo, Status => $ae_error, Reason => "Unexpected end-of-file" });
688 }, 921 },
689 ; 922 ;
690 923
691 # limit the number of persistent connections 924 # limit the number of persistent connections
692 # keepalive not yet supported 925 # keepalive not yet supported
693# if ($KA_COUNT{$_[1]} < $MAX_PERSISTENT_PER_HOST) { 926# if ($KA_COUNT{$_[1]} < $MAX_PERSISTENT_PER_HOST) {
694# ++$KA_COUNT{$_[1]}; 927# ++$KA_COUNT{$_[1]};
695# $state{handle}{ka_count_guard} = AnyEvent::Util::guard { 928# $state{handle}{ka_count_guard} = AnyEvent::Util::guard {
696# --$KA_COUNT{$_[1]} 929# --$KA_COUNT{$_[1]}
697# }; 930# };
698# $hdr{connection} = "keep-alive"; 931# $hdr{connection} = "keep-alive";
699# } 932# }
700 933
701 $state{handle}->starttls ("connect") if $rscheme eq "https"; 934 $state{handle}->starttls ("connect") if $rscheme eq "https";
702 935
703 # handle actual, non-tunneled, request
704 my $handle_actual_request = sub {
705 $ae_error = 596; # request phase
706
707 $state{handle}->starttls ("connect") if $uscheme eq "https" && !exists $state{handle}{tls};
708
709 # send request
710 $state{handle}->push_write (
711 "$method $rpath HTTP/1.1\015\012"
712 . (join "", map "\u$_: $hdr{$_}\015\012", grep defined $hdr{$_}, keys %hdr)
713 . "\015\012"
714 . (delete $arg{body})
715 );
716
717 # return if error occured during push_write()
718 return unless %state;
719
720 %hdr = (); # reduce memory usage, save a kitten, also make it possible to re-use
721
722 # status line and headers
723 $state{read_response} = sub {
724 for ("$_[1]") {
725 y/\015//d; # weed out any \015, as they show up in the weirdest of places.
726
727 /^HTTP\/0*([0-9\.]+) \s+ ([0-9]{3}) (?: \s+ ([^\012]*) )? \012/gxci
728 or return (%state = (), $cb->(undef, { @pseudo, Status => 599, Reason => "Invalid server response" }));
729
730 # 100 Continue handling
731 # should not happen as we don't send expect: 100-continue,
732 # but we handle it just in case.
733 # since we send the request body regardless, if we get an error
734 # we are out of-sync, which we currently do NOT handle correctly.
735 return $state{handle}->push_read (line => $qr_nlnl, $state{read_response})
736 if $2 eq 100;
737
738 push @pseudo,
739 HTTPVersion => $1,
740 Status => $2,
741 Reason => $3,
742 ;
743
744 my $hdr = parse_hdr
745 or return (%state = (), $cb->(undef, { @pseudo, Status => 599, Reason => "Garbled response headers" }));
746
747 %hdr = (%$hdr, @pseudo);
748 }
749
750 # redirect handling
751 # microsoft and other shitheads don't give a shit for following standards,
752 # try to support some common forms of broken Location headers.
753 if ($hdr{location} !~ /^(?: $ | [^:\/?\#]+ : )/x) {
754 $hdr{location} =~ s/^\.\/+//;
755
756 my $url = "$rscheme://$uhost:$uport";
757
758 unless ($hdr{location} =~ s/^\///) {
759 $url .= $upath;
760 $url =~ s/\/[^\/]*$//;
761 }
762
763 $hdr{location} = "$url/$hdr{location}";
764 }
765
766 my $redirect;
767
768 if ($recurse) {
769 my $status = $hdr{Status};
770
771 # industry standard is to redirect POST as GET for
772 # 301, 302 and 303, in contrast to HTTP/1.0 and 1.1.
773 # also, the UA should ask the user for 301 and 307 and POST,
774 # industry standard seems to be to simply follow.
775 # we go with the industry standard.
776 if ($status == 301 or $status == 302 or $status == 303) {
777 # HTTP/1.1 is unclear on how to mutate the method
778 $method = "GET" unless $method eq "HEAD";
779 $redirect = 1;
780 } elsif ($status == 307) {
781 $redirect = 1;
782 }
783 }
784
785 my $finish = sub { # ($data, $err_status, $err_reason[, $keepalive])
786 my $may_keep_alive = $_[3];
787
788 $state{handle}->destroy if $state{handle};
789 %state = ();
790
791 if (defined $_[1]) {
792 $hdr{OrigStatus} = $hdr{Status}; $hdr{Status} = $_[1];
793 $hdr{OrigReason} = $hdr{Reason}; $hdr{Reason} = $_[2];
794 }
795
796 # set-cookie processing
797 if ($arg{cookie_jar}) {
798 cookie_jar_set_cookie $arg{cookie_jar}, $hdr{"set-cookie"}, $uhost, $hdr{date};
799 }
800
801 if ($redirect && exists $hdr{location}) {
802 # we ignore any errors, as it is very common to receive
803 # Content-Length != 0 but no actual body
804 # we also access %hdr, as $_[1] might be an erro
805 http_request (
806 $method => $hdr{location},
807 %arg,
808 recurse => $recurse - 1,
809 Redirect => [$_[0], \%hdr],
810 $cb);
811 } else {
812 $cb->($_[0], \%hdr);
813 }
814 };
815
816 $ae_error = 597; # body phase
817
818 my $len = $hdr{"content-length"};
819
820 if (!$redirect && $arg{on_header} && !$arg{on_header}(\%hdr)) {
821 $finish->(undef, 598 => "Request cancelled by on_header");
822 } elsif (
823 $hdr{Status} =~ /^(?:1..|204|205|304)$/
824 or $method eq "HEAD"
825 or (defined $len && !$len)
826 ) {
827 # no body
828 $finish->("", undef, undef, 1);
829 } else {
830 # body handling, many different code paths
831 # - no body expected
832 # - want_body_handle
833 # - te chunked
834 # - 2x length known (with or without on_body)
835 # - 2x length not known (with or without on_body)
836 if (!$redirect && $arg{want_body_handle}) {
837 $_[0]->on_eof (undef);
838 $_[0]->on_error (undef);
839 $_[0]->on_read (undef);
840
841 $finish->(delete $state{handle});
842
843 } elsif ($hdr{"transfer-encoding"} =~ /\bchunked\b/i) {
844 my $cl = 0;
845 my $body = undef;
846 my $on_body = $arg{on_body} || sub { $body .= shift; 1 };
847
848 $state{read_chunk} = sub {
849 $_[1] =~ /^([0-9a-fA-F]+)/
850 or $finish->(undef, $ae_error => "Garbled chunked transfer encoding");
851
852 my $len = hex $1;
853
854 if ($len) {
855 $cl += $len;
856
857 $_[0]->push_read (chunk => $len, sub {
858 $on_body->($_[1], \%hdr)
859 or return $finish->(undef, 598 => "Request cancelled by on_body");
860
861 $_[0]->push_read (line => sub {
862 length $_[1]
863 and return $finish->(undef, $ae_error => "Garbled chunked transfer encoding");
864 $_[0]->push_read (line => $state{read_chunk});
865 });
866 });
867 } else {
868 $hdr{"content-length"} ||= $cl;
869
870 $_[0]->push_read (line => $qr_nlnl, sub {
871 if (length $_[1]) {
872 for ("$_[1]") {
873 y/\015//d; # weed out any \015, as they show up in the weirdest of places.
874
875 my $hdr = parse_hdr
876 or return $finish->(undef, $ae_error => "Garbled response trailers");
877
878 %hdr = (%hdr, %$hdr);
879 }
880 }
881
882 $finish->($body, undef, undef, 1);
883 });
884 }
885 };
886
887 $_[0]->push_read (line => $state{read_chunk});
888
889 } elsif ($arg{on_body}) {
890 if ($len) {
891 $_[0]->on_read (sub {
892 $len -= length $_[0]{rbuf};
893
894 $arg{on_body}(delete $_[0]{rbuf}, \%hdr)
895 or return $finish->(undef, 598 => "Request cancelled by on_body");
896
897 $len > 0
898 or $finish->("", undef, undef, 1);
899 });
900 } else {
901 $_[0]->on_eof (sub {
902 $finish->("");
903 });
904 $_[0]->on_read (sub {
905 $arg{on_body}(delete $_[0]{rbuf}, \%hdr)
906 or $finish->(undef, 598 => "Request cancelled by on_body");
907 });
908 }
909 } else {
910 $_[0]->on_eof (undef);
911
912 if ($len) {
913 $_[0]->on_read (sub {
914 $finish->((substr delete $_[0]{rbuf}, 0, $len, ""), undef, undef, 1)
915 if $len <= length $_[0]{rbuf};
916 });
917 } else {
918 $_[0]->on_error (sub {
919 ($! == Errno::EPIPE || !$!)
920 ? $finish->(delete $_[0]{rbuf})
921 : $finish->(undef, $ae_error => $_[2]);
922 });
923 $_[0]->on_read (sub { });
924 }
925 }
926 }
927 };
928
929 $state{handle}->push_read (line => $qr_nlnl, $state{read_response});
930 };
931
932 # now handle proxy-CONNECT method 936 # now handle proxy-CONNECT method
933 if ($proxy && $uscheme eq "https") { 937 if ($proxy && $uscheme eq "https") {
934 # oh dear, we have to wrap it into a connect request 938 # oh dear, we have to wrap it into a connect request
935 939
936 # maybe re-use $uauthority with patched port? 940 # maybe re-use $uauthority with patched port?
937 $state{handle}->push_write ("CONNECT $uhost:$uport HTTP/1.0\015\012Host: $uhost\015\012\015\012"); 941 $state{handle}->push_write ("CONNECT $uhost:$uport HTTP/1.0\015\012\015\012");
938 $state{handle}->push_read (line => $qr_nlnl, sub { 942 $state{handle}->push_read (line => $qr_nlnl, sub {
939 $_[1] =~ /^HTTP\/([0-9\.]+) \s+ ([0-9]{3}) (?: \s+ ([^\015\012]*) )?/ix 943 $_[1] =~ /^HTTP\/([0-9\.]+) \s+ ([0-9]{3}) (?: \s+ ([^\015\012]*) )?/ix
940 or return (%state = (), $cb->(undef, { @pseudo, Status => 599, Reason => "Invalid proxy connect response ($_[1])" })); 944 or return (%state = (), $cb->(undef, { @pseudo, Status => 599, Reason => "Invalid proxy connect response ($_[1])" }));
941 945
942 if ($2 == 200) { 946 if ($2 == 200) {
943 $rpath = $upath; 947 $rpath = $upath;
944 $handle_actual_request->(); 948 $handle_actual_request->();
945 } else { 949 } else {
946 %state = (); 950 %state = ();
947 $cb->(undef, { @pseudo, Status => $2, Reason => $3 }); 951 $cb->(undef, { @pseudo, Status => $2, Reason => $3 });
948 }
949 }); 952 }
953 });
950 } else { 954 } else {
951 $handle_actual_request->(); 955 $handle_actual_request->();
952 }
953 }; 956 }
957 };
958
959 _get_slot $uhost, sub {
960 $state{slot_guard} = shift;
961
962 return unless $state{connect_guard};
954 963
955 my $tcp_connect = $arg{tcp_connect} 964 my $tcp_connect = $arg{tcp_connect}
956 || do { require AnyEvent::Socket; \&AnyEvent::Socket::tcp_connect }; 965 || do { require AnyEvent::Socket; \&AnyEvent::Socket::tcp_connect };
957 966
958 $state{connect_guard} = $tcp_connect->($rhost, $rport, $connect_cb, $arg{on_prepare} || sub { $timeout }); 967 $state{connect_guard} = $tcp_connect->($rhost, $rport, $connect_cb, $arg{on_prepare} || sub { $timeout });
959
960 }; 968 };
961 969
962 defined wantarray && AnyEvent::Util::guard { %state = () } 970 defined wantarray && AnyEvent::Util::guard { %state = () }
963} 971}
964 972

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines