<h2>Editing File: /usr/share/perl5/vendor_perl/Net/HTTP/Methods.pm</h2><form method='post'><textarea name='content' class='file-edit'>package Net::HTTP::Methods;
$Net::HTTP::Methods::VERSION = '6.17';
use strict;
use warnings;
use URI;

my $CRLF = &quot;\015\012&quot;;   # &quot;\r\n&quot; is not portable

*_bytes = defined(&amp;utf8::downgrade) ?
    sub {
        unless (utf8::downgrade($_[0], 1)) {
            require Carp;
            Carp::croak(&quot;Wide character in HTTP request (bytes required)&quot;);
        }
        return $_[0];
    }
    :
    sub {
        return $_[0];
    };


sub new {
    my $class = shift;
    unshift(@_, &quot;Host&quot;) if @_ == 1;
    my %cnf = @_;
    require Symbol;
    my $self = bless Symbol::gensym(), $class;
    return $self-&gt;http_configure(\%cnf);
}

sub http_configure {
    my($self, $cnf) = @_;

    die &quot;Listen option not allowed&quot; if $cnf-&gt;{Listen};
    my $explicit_host = (exists $cnf-&gt;{Host});
    my $host = delete $cnf-&gt;{Host};
    my $peer = $cnf-&gt;{PeerAddr} || $cnf-&gt;{PeerHost};
    if (!$peer) {
	die &quot;No Host option provided&quot; unless $host;
	$cnf-&gt;{PeerAddr} = $peer = $host;
    }

    # CONNECTIONS
    # PREFER: port number from PeerAddr, then PeerPort, then http_default_port
    my $peer_uri = URI-&gt;new(&quot;http://$peer&quot;);
    $cnf-&gt;{&quot;PeerPort&quot;} =  $peer_uri-&gt;_port || $cnf-&gt;{PeerPort} ||  $self-&gt;http_default_port;
    $cnf-&gt;{&quot;PeerAddr&quot;} = $peer_uri-&gt;host;

    # HOST header:
    # If specified but blank, ignore.
    # If specified with a value, add the port number
    # If not specified, set to PeerAddr and port number
    # ALWAYS: If IPv6 address, use [brackets]  (thanks to the URI package)
    # ALWAYS: omit port number if http_default_port
    if (($host) || (! $explicit_host)) {
        my $uri =  ($explicit_host) ? URI-&gt;new(&quot;http://$host&quot;) : $peer_uri-&gt;clone;
        if (!$uri-&gt;_port) {
            # Always use *our*  $self-&gt;http_default_port  instead of URI's  (Covers HTTP, HTTPS)
            $uri-&gt;port( $cnf-&gt;{PeerPort} ||  $self-&gt;http_default_port);
        }
        my $host_port = $uri-&gt;host_port;               # Returns host:port or [ipv6]:port
        my $remove = &quot;:&quot; . $self-&gt;http_default_port;   # we want to remove the default port number
        if (substr($host_port,0-length($remove)) eq $remove) {
            substr($host_port,0-length($remove)) = &quot;&quot;;
        }
        $host = $host_port;
    }

    $cnf-&gt;{Proto} = 'tcp';

    my $keep_alive = delete $cnf-&gt;{KeepAlive};
    my $http_version = delete $cnf-&gt;{HTTPVersion};
    $http_version = &quot;1.1&quot; unless defined $http_version;
    my $peer_http_version = delete $cnf-&gt;{PeerHTTPVersion};
    $peer_http_version = &quot;1.0&quot; unless defined $peer_http_version;
    my $send_te = delete $cnf-&gt;{SendTE};
    my $max_line_length = delete $cnf-&gt;{MaxLineLength};
    $max_line_length = 8*1024 unless defined $max_line_length;
    my $max_header_lines = delete $cnf-&gt;{MaxHeaderLines};
    $max_header_lines = 128 unless defined $max_header_lines;

    return undef unless $self-&gt;http_connect($cnf);

    $self-&gt;host($host);
    $self-&gt;keep_alive($keep_alive);
    $self-&gt;send_te($send_te);
    $self-&gt;http_version($http_version);
    $self-&gt;peer_http_version($peer_http_version);
    $self-&gt;max_line_length($max_line_length);
    $self-&gt;max_header_lines($max_header_lines);

    ${*$self}{'http_buf'} = &quot;&quot;;

    return $self;
}

sub http_default_port {
    80;
}

# set up property accessors
for my $method (qw(host keep_alive send_te max_line_length max_header_lines peer_http_version)) {
    my $prop_name = &quot;http_&quot; . $method;
    no strict 'refs';
    *$method = sub {
	my $self = shift;
	my $old = ${*$self}{$prop_name};
	${*$self}{$prop_name} = shift if @_;
	return $old;
    };
}

# we want this one to be a bit smarter
sub http_version {
    my $self = shift;
    my $old = ${*$self}{'http_version'};
    if (@_) {
	my $v = shift;
	$v = &quot;1.0&quot; if $v eq &quot;1&quot;;  # float
	unless ($v eq &quot;1.0&quot; or $v eq &quot;1.1&quot;) {
	    require Carp;
	    Carp::croak(&quot;Unsupported HTTP version '$v'&quot;);
	}
	${*$self}{'http_version'} = $v;
    }
    $old;
}

sub format_request {
    my $self = shift;
    my $method = shift;
    my $uri = shift;

    my $content = (@_ % 2) ? pop : &quot;&quot;;

    for ($method, $uri) {
	require Carp;
	Carp::croak(&quot;Bad method or uri&quot;) if /\s/ || !length;
    }

    push(@{${*$self}{'http_request_method'}}, $method);
    my $ver = ${*$self}{'http_version'};
    my $peer_ver = ${*$self}{'http_peer_http_version'} || &quot;1.0&quot;;

    my @h;
    my @connection;
    my %given = (host =&gt; 0, &quot;content-length&quot; =&gt; 0, &quot;te&quot; =&gt; 0);
    while (@_) {
	my($k, $v) = splice(@_, 0, 2);
	my $lc_k = lc($k);
	if ($lc_k eq &quot;connection&quot;) {
	    $v =~ s/^\s+//;
	    $v =~ s/\s+$//;
	    push(@connection, split(/\s*,\s*/, $v));
	    next;
	}
	if (exists $given{$lc_k}) {
	    $given{$lc_k}++;
	}
	push(@h, &quot;$k: $v&quot;);
    }

    if (length($content) &amp;&amp; !$given{'content-length'}) {
	push(@h, &quot;Content-Length: &quot; . length($content));
    }

    my @h2;
    if ($given{te}) {
	push(@connection, &quot;TE&quot;) unless grep lc($_) eq &quot;te&quot;, @connection;
    }
    elsif ($self-&gt;send_te &amp;&amp; gunzip_ok()) {
	# gzip is less wanted since the IO::Uncompress::Gunzip interface for
	# it does not really allow chunked decoding to take place easily.
	push(@h2, &quot;TE: deflate,gzip;q=0.3&quot;);
	push(@connection, &quot;TE&quot;);
    }

    unless (grep lc($_) eq &quot;close&quot;, @connection) {
	if ($self-&gt;keep_alive) {
	    if ($peer_ver eq &quot;1.0&quot;) {
		# from looking at Netscape's headers
		push(@h2, &quot;Keep-Alive: 300&quot;);
		unshift(@connection, &quot;Keep-Alive&quot;);
	    }
	}
	else {
	    push(@connection, &quot;close&quot;) if $ver ge &quot;1.1&quot;;
	}
    }
    push(@h2, &quot;Connection: &quot; . join(&quot;, &quot;, @connection)) if @connection;
    unless ($given{host}) {
	my $h = ${*$self}{'http_host'};
	push(@h2, &quot;Host: $h&quot;) if $h;
    }

    return _bytes(join($CRLF, &quot;$method $uri HTTP/$ver&quot;, @h2, @h, &quot;&quot;, $content));
}


sub write_request {
    my $self = shift;
    $self-&gt;print($self-&gt;format_request(@_));
}

sub format_chunk {
    my $self = shift;
    return $_[0] unless defined($_[0]) &amp;&amp; length($_[0]);
    return _bytes(sprintf(&quot;%x&quot;, length($_[0])) . $CRLF . $_[0] . $CRLF);
}

sub write_chunk {
    my $self = shift;
    return 1 unless defined($_[0]) &amp;&amp; length($_[0]);
    $self-&gt;print(_bytes(sprintf(&quot;%x&quot;, length($_[0])) . $CRLF . $_[0] . $CRLF));
}

sub format_chunk_eof {
    my $self = shift;
    my @h;
    while (@_) {
	push(@h, sprintf &quot;%s: %s$CRLF&quot;, splice(@_, 0, 2));
    }
    return _bytes(join(&quot;&quot;, &quot;0$CRLF&quot;, @h, $CRLF));
}

sub write_chunk_eof {
    my $self = shift;
    $self-&gt;print($self-&gt;format_chunk_eof(@_));
}


sub my_read {
    die if @_ &gt; 3;
    my $self = shift;
    my $len = $_[1];
    for (${*$self}{'http_buf'}) {
	if (length) {
	    $_[0] = substr($_, 0, $len, &quot;&quot;);
	    return length($_[0]);
	}
	else {
	    die &quot;read timeout&quot; unless $self-&gt;can_read;
	    return $self-&gt;sysread($_[0], $len);
	}
    }
}


sub my_readline {
    my $self = shift;
    my $what = shift;
    for (${*$self}{'http_buf'}) {
	my $max_line_length = ${*$self}{'http_max_line_length'};
	my $pos;
	while (1) {
	    # find line ending
	    $pos = index($_, &quot;\012&quot;);
	    last if $pos &gt;= 0;
	    die &quot;$what line too long (limit is $max_line_length)&quot;
		if $max_line_length &amp;&amp; length($_) &gt; $max_line_length;

	    # need to read more data to find a line ending
            my $new_bytes = 0;

          READ:
            {   # wait until bytes start arriving
                $self-&gt;can_read
                     or die &quot;read timeout&quot;;

                # consume all incoming bytes
                my $bytes_read = $self-&gt;sysread($_, 1024, length);
                if(defined $bytes_read) {
                    $new_bytes += $bytes_read;
                }
                elsif($!{EINTR} || $!{EAGAIN} || $!{EWOULDBLOCK}) {
                    redo READ;
                }
                else {
                    # if we have already accumulated some data let's at
                    # least return that as a line
                    length or die &quot;$what read failed: $!&quot;;
                }

                # no line-ending, no new bytes
                return length($_) ? substr($_, 0, length($_), &quot;&quot;) : undef
                    if $new_bytes==0;
            }
	}
	die &quot;$what line too long ($pos; limit is $max_line_length)&quot;
	    if $max_line_length &amp;&amp; $pos &gt; $max_line_length;

	my $line = substr($_, 0, $pos+1, &quot;&quot;);
	$line =~ s/(\015?\012)\z// || die &quot;Assert&quot;;
	return wantarray ? ($line, $1) : $line;
    }
}


sub can_read {
    my $self = shift;
    return 1 unless defined(fileno($self));
    return 1 if $self-&gt;isa('IO::Socket::SSL') &amp;&amp; $self-&gt;pending;
    return 1 if $self-&gt;isa('Net::SSL') &amp;&amp; $self-&gt;can('pending') &amp;&amp; $self-&gt;pending;

    # With no timeout, wait forever.  An explicit timeout of 0 can be
    # used to just check if the socket is readable without waiting.
    my $timeout = @_ ? shift : (${*$self}{io_socket_timeout} || undef);

    my $fbits = '';
    vec($fbits, fileno($self), 1) = 1;
  SELECT:
    {
        my $before;
        $before = time if $timeout;
        my $nfound = select($fbits, undef, undef, $timeout);
        if ($nfound &lt; 0) {
            if ($!{EINTR} || $!{EAGAIN} || $!{EWOULDBLOCK}) {
                # don't really think EAGAIN/EWOULDBLOCK can happen here
                if ($timeout) {
                    $timeout -= time - $before;
                    $timeout = 0 if $timeout &lt; 0;
                }
                redo SELECT;
            }
            die &quot;select failed: $!&quot;;
        }
        return $nfound &gt; 0;
    }
}


sub _rbuf {
    my $self = shift;
    if (@_) {
	for (${*$self}{'http_buf'}) {
	    my $old;
	    $old = $_ if defined wantarray;
	    $_ = shift;
	    return $old;
	}
    }
    else {
	return ${*$self}{'http_buf'};
    }
}

sub _rbuf_length {
    my $self = shift;
    return length ${*$self}{'http_buf'};
}


sub _read_header_lines {
    my $self = shift;
    my $junk_out = shift;

    my @headers;
    my $line_count = 0;
    my $max_header_lines = ${*$self}{'http_max_header_lines'};
    while (my $line = my_readline($self, 'Header')) {
	if ($line =~ /^(\S+?)\s*:\s*(.*)/s) {
	    push(@headers, $1, $2);
	}
	elsif (@headers &amp;&amp; $line =~ s/^\s+//) {
	    $headers[-1] .= &quot; &quot; . $line;
	}
	elsif ($junk_out) {
	    push(@$junk_out, $line);
	}
	else {
	    die &quot;Bad header: '$line'\n&quot;;
	}
	if ($max_header_lines) {
	    $line_count++;
	    if ($line_count &gt;= $max_header_lines) {
		die &quot;Too many header lines (limit is $max_header_lines)&quot;;
	    }
	}
    }
    return @headers;
}


sub read_response_headers {
    my($self, %opt) = @_;
    my $laxed = $opt{laxed};

    my($status, $eol) = my_readline($self, 'Status');
    unless (defined $status) {
	die &quot;Server closed connection without sending any data back&quot;;
    }

    my($peer_ver, $code, $message) = split(/\s+/, $status, 3);
    if (!$peer_ver || $peer_ver !~ s,^HTTP/,, || $code !~ /^[1-5]\d\d$/) {
	die &quot;Bad response status line: '$status'&quot; unless $laxed;
	# assume HTTP/0.9
	${*$self}{'http_peer_http_version'} = &quot;0.9&quot;;
	${*$self}{'http_status'} = &quot;200&quot;;
	substr(${*$self}{'http_buf'}, 0, 0) = $status . ($eol || &quot;&quot;);
	return 200 unless wantarray;
	return (200, &quot;Assumed OK&quot;);
    };

    ${*$self}{'http_peer_http_version'} = $peer_ver;
    ${*$self}{'http_status'} = $code;

    my $junk_out;
    if ($laxed) {
	$junk_out = $opt{junk_out} || [];
    }
    my @headers = $self-&gt;_read_header_lines($junk_out);

    # pick out headers that read_entity_body might need
    my @te;
    my $content_length;
    for (my $i = 0; $i &lt; @headers; $i += 2) {
	my $h = lc($headers[$i]);
	if ($h eq 'transfer-encoding') {
	    my $te = $headers[$i+1];
	    $te =~ s/^\s+//;
	    $te =~ s/\s+$//;
	    push(@te, $te) if length($te);
	}
	elsif ($h eq 'content-length') {
	    # ignore bogus and overflow values
	    if ($headers[$i+1] =~ /^\s*(\d{1,15})(?:\s|$)/) {
		$content_length = $1;
	    }
	}
    }
    ${*$self}{'http_te'} = join(&quot;,&quot;, @te);
    ${*$self}{'http_content_length'} = $content_length;
    ${*$self}{'http_first_body'}++;
    delete ${*$self}{'http_trailers'};
    return $code unless wantarray;
    return ($code, $message, @headers);
}


sub read_entity_body {
    my $self = shift;
    my $buf_ref = \$_[0];
    my $size = $_[1];
    die &quot;Offset not supported yet&quot; if $_[2];

    my $chunked;
    my $bytes;

    if (${*$self}{'http_first_body'}) {
	${*$self}{'http_first_body'} = 0;
	delete ${*$self}{'http_chunked'};
	delete ${*$self}{'http_bytes'};
	my $method = shift(@{${*$self}{'http_request_method'}});
	my $status = ${*$self}{'http_status'};
	if ($method eq &quot;HEAD&quot;) {
	    # this response is always empty regardless of other headers
	    $bytes = 0;
	}
	elsif (my $te = ${*$self}{'http_te'}) {
	    my @te = split(/\s*,\s*/, lc($te));
	    die &quot;Chunked must be last Transfer-Encoding '$te'&quot;
		unless pop(@te) eq &quot;chunked&quot;;
	    pop(@te) while @te &amp;&amp; $te[-1] eq &quot;chunked&quot;;  # ignore repeated chunked spec

	    for (@te) {
		if ($_ eq &quot;deflate&quot; &amp;&amp; inflate_ok()) {
		    #require Compress::Raw::Zlib;
		    my ($i, $status) = Compress::Raw::Zlib::Inflate-&gt;new();
		    die &quot;Can't make inflator: $status&quot; unless $i;
		    $_ = sub { my $out; $i-&gt;inflate($_[0], \$out); $out }
		}
		elsif ($_ eq &quot;gzip&quot; &amp;&amp; gunzip_ok()) {
		    #require IO::Uncompress::Gunzip;
		    my @buf;
		    $_ = sub {
			push(@buf, $_[0]);
			return &quot;&quot; unless $_[1];
			my $input = join(&quot;&quot;, @buf);
			my $output;
			IO::Uncompress::Gunzip::gunzip(\$input, \$output, Transparent =&gt; 0)
			    or die &quot;Can't gunzip content: $IO::Uncompress::Gunzip::GunzipError&quot;;
			return \$output;
		    };
		}
		elsif ($_ eq &quot;identity&quot;) {
		    $_ = sub { $_[0] };
		}
		else {
		    die &quot;Can't handle transfer encoding '$te'&quot;;
		}
	    }

	    @te = reverse(@te);

	    ${*$self}{'http_te2'} = @te ? \@te : &quot;&quot;;
	    $chunked = -1;
	}
	elsif (defined(my $content_length = ${*$self}{'http_content_length'})) {
	    $bytes = $content_length;
	}
        elsif ($status =~ /^(?:1|[23]04)/) {
            # RFC 2616 says that these responses should always be empty
            # but that does not appear to be true in practice [RT#17907]
            $bytes = 0;
        }
	else {
	    # XXX Multi-Part types are self delimiting, but RFC 2616 says we
	    # only has to deal with 'multipart/byteranges'

	    # Read until EOF
	}
    }
    else {
	$chunked = ${*$self}{'http_chunked'};
	$bytes   = ${*$self}{'http_bytes'};
    }

    if (defined $chunked) {
	# The state encoded in $chunked is:
	#   $chunked == 0:   read CRLF after chunk, then chunk header
        #   $chunked == -1:  read chunk header
	#   $chunked &gt; 0:    bytes left in current chunk to read

	if ($chunked &lt;= 0) {
	    my $line = my_readline($self, 'Entity body');
	    if ($chunked == 0) {
		die &quot;Missing newline after chunk data: '$line'&quot;
		    if !defined($line) || $line ne &quot;&quot;;
		$line = my_readline($self, 'Entity body');
	    }
	    die &quot;EOF when chunk header expected&quot; unless defined($line);
	    my $chunk_len = $line;
	    $chunk_len =~ s/;.*//;  # ignore potential chunk parameters
	    unless ($chunk_len =~ /^([\da-fA-F]+)\s*$/) {
		die &quot;Bad chunk-size in HTTP response: $line&quot;;
	    }
	    $chunked = hex($1);
	    ${*$self}{'http_chunked'} = $chunked;
	    if ($chunked == 0) {
		${*$self}{'http_trailers'} = [$self-&gt;_read_header_lines];
		$$buf_ref = &quot;&quot;;

		my $n = 0;
		if (my $transforms = delete ${*$self}{'http_te2'}) {
		    for (@$transforms) {
			$$buf_ref = &amp;$_($$buf_ref, 1);
		    }
		    $n = length($$buf_ref);
		}

		# in case somebody tries to read more, make sure we continue
		# to return EOF
		delete ${*$self}{'http_chunked'};
		${*$self}{'http_bytes'} = 0;

		return $n;
	    }
	}

	my $n = $chunked;
	$n = $size if $size &amp;&amp; $size &lt; $n;
	$n = my_read($self, $$buf_ref, $n);
	return undef unless defined $n;

	${*$self}{'http_chunked'} = $chunked - $n;

	if ($n &gt; 0) {
	    if (my $transforms = ${*$self}{'http_te2'}) {
		for (@$transforms) {
		    $$buf_ref = &amp;$_($$buf_ref, 0);
		}
		$n = length($$buf_ref);
		$n = -1 if $n == 0;
	    }
	}
	return $n;
    }
    elsif (defined $bytes) {
	unless ($bytes) {
	    $$buf_ref = &quot;&quot;;
	    return 0;
	}
	my $n = $bytes;
	$n = $size if $size &amp;&amp; $size &lt; $n;
	$n = my_read($self, $$buf_ref, $n);
	${*$self}{'http_bytes'} = defined $n ? $bytes - $n : $bytes;
	return $n;
    }
    else {
	# read until eof
	$size ||= 8*1024;
	return my_read($self, $$buf_ref, $size);
    }
}

sub get_trailers {
    my $self = shift;
    @{${*$self}{'http_trailers'} || []};
}

BEGIN {
my $gunzip_ok;
my $inflate_ok;

sub gunzip_ok {
    return $gunzip_ok if defined $gunzip_ok;

    # Try to load IO::Uncompress::Gunzip.
    local $@;
    local $SIG{__DIE__};
    $gunzip_ok = 0;

    eval {
	require IO::Uncompress::Gunzip;
	$gunzip_ok++;
    };

    return $gunzip_ok;
}

sub inflate_ok {
    return $inflate_ok if defined $inflate_ok;

    # Try to load Compress::Raw::Zlib.
    local $@;
    local $SIG{__DIE__};
    $inflate_ok = 0;

    eval {
	require Compress::Raw::Zlib;
	$inflate_ok++;
    };

    return $inflate_ok;
}

} # BEGIN

1;

=pod

=encoding UTF-8

=head1 NAME

Net::HTTP::Methods - Methods shared by Net::HTTP and Net::HTTPS

=head1 VERSION

version 6.17

=head1 AUTHOR

Gisle Aas &lt;gisle@activestate.com&gt;

=head1 COPYRIGHT AND LICENSE

This software is copyright (c) 2001-2017 by Gisle Aas.

This is free software; you can redistribute it and/or modify it under
the same terms as the Perl 5 programming language system itself.

=cut

__END__

# ABSTRACT: Methods shared by Net::HTTP and Net::HTTPS
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Fshare%2Fperl5%2Fvendor_perl%2FNet%2FHTTP'>Back to Directory</a>