summaryrefslogtreecommitdiff
path: root/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP
diff options
context:
space:
mode:
authorNorbert Preining <norbert@preining.info>2024-03-15 03:06:35 +0000
committerNorbert Preining <norbert@preining.info>2024-03-15 03:06:35 +0000
commit12679ab7d3c2a210f4123163671b532b8b55d5f9 (patch)
tree0060d13467186ad977f4e73488ee20dd6c0017ab /systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP
parent62170822e034fdd3f81de7274835d0d3b0467100 (diff)
CTAN sync 202403150306
Diffstat (limited to 'systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP')
-rw-r--r--systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Authen/Basic.pm86
-rw-r--r--systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Authen/Digest.pm80
-rw-r--r--systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Authen/Ntlm.pm183
-rw-r--r--systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/ConnCache.pm350
-rw-r--r--systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Debug.pm112
-rw-r--r--systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Debug/TraceHTTP.pm29
-rw-r--r--systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/DebugFile.pm7
-rw-r--r--systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/MemberMixin.pm48
-rw-r--r--systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol.pm313
-rw-r--r--systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/cpan.pm72
-rw-r--r--systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/data.pm52
-rw-r--r--systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/file.pm147
-rw-r--r--systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/ftp.pm555
-rw-r--r--systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/gopher.pm213
-rw-r--r--systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/http.pm523
-rw-r--r--systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/loopback.pm27
-rw-r--r--systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/mailto.pm184
-rw-r--r--systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/nntp.pm150
-rw-r--r--systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/nogo.pm25
-rw-r--r--systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/RobotUA.pm312
-rw-r--r--systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Simple.pm267
-rw-r--r--systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/UserAgent.pm2179
22 files changed, 0 insertions, 5914 deletions
diff --git a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Authen/Basic.pm b/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Authen/Basic.pm
deleted file mode 100644
index 6af1441bdd..0000000000
--- a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Authen/Basic.pm
+++ /dev/null
@@ -1,86 +0,0 @@
-package LWP::Authen::Basic;
-
-use strict;
-
-our $VERSION = '6.61';
-
-require Encode;
-require MIME::Base64;
-
-sub auth_header {
- my($class, $user, $pass, $request, $ua, $h) = @_;
-
- my $userpass = "$user:$pass";
- # https://tools.ietf.org/html/rfc7617#section-2.1
- my $charset = uc($h->{auth_param}->{charset} || "");
- $userpass = Encode::encode($charset, $userpass)
- if ($charset eq "UTF-8");
-
- return "Basic " . MIME::Base64::encode($userpass, "");
-}
-
-sub _reauth_requested {
- return 0;
-}
-
-sub authenticate
-{
- my($class, $ua, $proxy, $auth_param, $response,
- $request, $arg, $size) = @_;
-
- my $realm = $auth_param->{realm} || "";
- my $url = $proxy ? $request->{proxy} : $request->uri_canonical;
- return $response unless $url;
- my $host_port = $url->host_port;
- my $auth_header = $proxy ? "Proxy-Authorization" : "Authorization";
-
- my @m = $proxy ? (m_proxy => $url) : (m_host_port => $host_port);
- push(@m, realm => $realm);
-
- my $h = $ua->get_my_handler("request_prepare", @m, sub {
- $_[0]{callback} = sub {
- my($req, $ua, $h) = @_;
- my($user, $pass) = $ua->credentials($host_port, $h->{realm});
- if (defined $user) {
- my $auth_value = $class->auth_header($user, $pass, $req, $ua, $h);
- $req->header($auth_header => $auth_value);
- }
- };
- });
- $h->{auth_param} = $auth_param;
-
- my $reauth_requested
- = $class->_reauth_requested($auth_param, $ua, $request, $auth_header);
- if ( !$proxy
- && (!$request->header($auth_header) || $reauth_requested)
- && $ua->credentials($host_port, $realm))
- {
- # we can make sure this handler applies and retry
- add_path($h, $url->path)
- unless $reauth_requested; # Do not clobber up path list for retries
- return $ua->request($request->clone, $arg, $size, $response);
- }
-
- my($user, $pass) = $ua->get_basic_credentials($realm, $url, $proxy);
- unless (defined $user and defined $pass) {
- $ua->set_my_handler("request_prepare", undef, @m); # delete handler
- return $response;
- }
-
- # check that the password has changed
- my ($olduser, $oldpass) = $ua->credentials($host_port, $realm);
- return $response if (defined $olduser and defined $oldpass and
- $user eq $olduser and $pass eq $oldpass);
-
- $ua->credentials($host_port, $realm, $user, $pass);
- add_path($h, $url->path) unless $proxy;
- return $ua->request($request->clone, $arg, $size, $response);
-}
-
-sub add_path {
- my($h, $path) = @_;
- $path =~ s,[^/]+\z,,;
- push(@{$h->{m_path_prefix}}, $path);
-}
-
-1;
diff --git a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Authen/Digest.pm b/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Authen/Digest.pm
deleted file mode 100644
index bb1d9ae3c8..0000000000
--- a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Authen/Digest.pm
+++ /dev/null
@@ -1,80 +0,0 @@
-package LWP::Authen::Digest;
-
-use strict;
-use parent 'LWP::Authen::Basic';
-
-our $VERSION = '6.61';
-
-require Digest::MD5;
-
-sub _reauth_requested {
- my ($class, $auth_param, $ua, $request, $auth_header) = @_;
- my $ret = defined($$auth_param{stale}) && lc($$auth_param{stale}) eq 'true';
- if ($ret) {
- my $hdr = $request->header($auth_header);
- $hdr =~ tr/,/;/; # "," is used to separate auth-params!!
- ($hdr) = HTTP::Headers::Util::split_header_words($hdr);
- my $nonce = {@$hdr}->{nonce};
- delete $$ua{authen_md5_nonce_count}{$nonce};
- }
- return $ret;
-}
-
-sub auth_header {
- my($class, $user, $pass, $request, $ua, $h) = @_;
-
- my $auth_param = $h->{auth_param};
-
- my $nc = sprintf "%08X", ++$ua->{authen_md5_nonce_count}{$auth_param->{nonce}};
- my $cnonce = sprintf "%8x", time;
-
- my $uri = $request->uri->path_query;
- $uri = "/" unless length $uri;
-
- my $md5 = Digest::MD5->new;
-
- my(@digest);
- $md5->add(join(":", $user, $auth_param->{realm}, $pass));
- push(@digest, $md5->hexdigest);
- $md5->reset;
-
- push(@digest, $auth_param->{nonce});
-
- if ($auth_param->{qop}) {
- push(@digest, $nc, $cnonce, ($auth_param->{qop} =~ m|^auth[,;]auth-int$|) ? 'auth' : $auth_param->{qop});
- }
-
- $md5->add(join(":", $request->method, $uri));
- push(@digest, $md5->hexdigest);
- $md5->reset;
-
- $md5->add(join(":", @digest));
- my($digest) = $md5->hexdigest;
- $md5->reset;
-
- my %resp = map { $_ => $auth_param->{$_} } qw(realm nonce opaque);
- @resp{qw(username uri response algorithm)} = ($user, $uri, $digest, "MD5");
-
- if (($auth_param->{qop} || "") =~ m|^auth([,;]auth-int)?$|) {
- @resp{qw(qop cnonce nc)} = ("auth", $cnonce, $nc);
- }
-
- my(@order) = qw(username realm qop algorithm uri nonce nc cnonce response opaque);
- my @pairs;
- for (@order) {
- next unless defined $resp{$_};
-
- # RFC2617 says that qop-value and nc-value should be unquoted.
- if ( $_ eq 'qop' || $_ eq 'nc' ) {
- push(@pairs, "$_=" . $resp{$_});
- }
- else {
- push(@pairs, "$_=" . qq("$resp{$_}"));
- }
- }
-
- my $auth_value = "Digest " . join(", ", @pairs);
- return $auth_value;
-}
-
-1;
diff --git a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Authen/Ntlm.pm b/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Authen/Ntlm.pm
deleted file mode 100644
index de745af6ac..0000000000
--- a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Authen/Ntlm.pm
+++ /dev/null
@@ -1,183 +0,0 @@
-package LWP::Authen::Ntlm;
-
-use strict;
-
-our $VERSION = '6.61';
-
-use Authen::NTLM "1.02";
-use MIME::Base64 "2.12";
-
-sub authenticate {
- my($class, $ua, $proxy, $auth_param, $response,
- $request, $arg, $size) = @_;
-
- my($user, $pass) = $ua->get_basic_credentials($auth_param->{realm},
- $request->uri, $proxy);
-
- unless(defined $user and defined $pass) {
- return $response;
- }
-
- if (!$ua->conn_cache()) {
- warn "The keep_alive option must be enabled for NTLM authentication to work. NTLM authentication aborted.\n";
- return $response;
- }
-
- my($domain, $username) = split(/\\/, $user);
-
- ntlm_domain($domain);
- ntlm_user($username);
- ntlm_password($pass);
-
- my $auth_header = $proxy ? "Proxy-Authorization" : "Authorization";
-
- # my ($challenge) = $response->header('WWW-Authenticate');
- my $challenge;
- foreach ($response->header('WWW-Authenticate')) {
- last if /^NTLM/ && ($challenge=$_);
- }
-
- if ($challenge eq 'NTLM') {
- # First phase, send handshake
- my $auth_value = "NTLM " . ntlm();
- ntlm_reset();
-
- # Need to check this isn't a repeated fail!
- my $r = $response;
- my $retry_count = 0;
- while ($r) {
- my $auth = $r->request->header($auth_header);
- ++$retry_count if ($auth && $auth eq $auth_value);
- if ($retry_count > 2) {
- # here we know this failed before
- $response->header("Client-Warning" =>
- "Credentials for '$user' failed before");
- return $response;
- }
- $r = $r->previous;
- }
-
- my $referral = $request->clone;
- $referral->header($auth_header => $auth_value);
- return $ua->request($referral, $arg, $size, $response);
- }
-
- else {
- # Second phase, use the response challenge (unless non-401 code
- # was returned, in which case, we just send back the response
- # object, as is
- my $auth_value;
- if ($response->code ne '401') {
- return $response;
- }
- else {
- my $challenge;
- foreach ($response->header('WWW-Authenticate')) {
- last if /^NTLM/ && ($challenge=$_);
- }
- $challenge =~ s/^NTLM //;
- ntlm();
- $auth_value = "NTLM " . ntlm($challenge);
- ntlm_reset();
- }
-
- my $referral = $request->clone;
- $referral->header($auth_header => $auth_value);
- my $response2 = $ua->request($referral, $arg, $size, $response);
- return $response2;
- }
-}
-
-1;
-__END__
-
-=pod
-
-=head1 NAME
-
-LWP::Authen::Ntlm - Library for enabling NTLM authentication (Microsoft) in LWP
-
-=head1 SYNOPSIS
-
- use LWP::UserAgent;
- use HTTP::Request::Common;
- my $url = 'http://www.company.com/protected_page.html';
-
- # Set up the ntlm client and then the base64 encoded ntlm handshake message
- my $ua = LWP::UserAgent->new(keep_alive=>1);
- $ua->credentials('www.company.com:80', '', "MyDomain\\MyUserCode", 'MyPassword');
-
- $request = GET $url;
- print "--Performing request now...-----------\n";
- $response = $ua->request($request);
- print "--Done with request-------------------\n";
-
- if ($response->is_success) {print "It worked!->" . $response->code . "\n"}
- else {print "It didn't work!->" . $response->code . "\n"}
-
-=head1 DESCRIPTION
-
-L<LWP::Authen::Ntlm> allows LWP to authenticate against servers that are using the
-NTLM authentication scheme popularized by Microsoft. This type of authentication is
-common on intranets of Microsoft-centric organizations.
-
-The module takes advantage of the Authen::NTLM module by Mark Bush. Since there
-is also another Authen::NTLM module available from CPAN by Yee Man Chan with an
-entirely different interface, it is necessary to ensure that you have the correct
-NTLM module.
-
-In addition, there have been problems with incompatibilities between different
-versions of L<Mime::Base64>, which Bush's L<Authen::NTLM> makes use of. Therefore, it is
-necessary to ensure that your Mime::Base64 module supports exporting of the
-C<encode_base64> and C<decode_base64> functions.
-
-=head1 USAGE
-
-The module is used indirectly through LWP, rather than including it directly in your
-code. The LWP system will invoke the NTLM authentication when it encounters the
-authentication scheme while attempting to retrieve a URL from a server. In order
-for the NTLM authentication to work, you must have a few things set up in your
-code prior to attempting to retrieve the URL:
-
-=over 4
-
-=item *
-
-Enable persistent HTTP connections
-
-To do this, pass the C<< "keep_alive=>1" >> option to the L<LWP::UserAgent> when creating it, like this:
-
- my $ua = LWP::UserAgent->new(keep_alive=>1);
-
-=item *
-
-Set the credentials on the UserAgent object
-
-The credentials must be set like this:
-
- $ua->credentials('www.company.com:80', '', "MyDomain\\MyUserCode", 'MyPassword');
-
-Note that you cannot use the L<HTTP::Request> object's C<authorization_basic()> method to set
-the credentials. Note, too, that the C<'www.company.com:80'> portion only sets credentials
-on the specified port AND it is case-sensitive (this is due to the way LWP is coded, and
-has nothing to do with LWP::Authen::Ntlm)
-
-=back
-
-=head1 AVAILABILITY
-
-General queries regarding LWP should be made to the LWP Mailing List.
-
-Questions specific to LWP::Authen::Ntlm can be forwarded to jtillman@bigfoot.com
-
-=head1 COPYRIGHT
-
-Copyright (c) 2002 James Tillman. All rights reserved. This
-program is free software; you can redistribute it and/or modify it
-under the same terms as Perl itself.
-
-=head1 SEE ALSO
-
-L<LWP>, L<LWP::UserAgent>, L<lwpcook>.
-
-=cut
diff --git a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/ConnCache.pm b/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/ConnCache.pm
deleted file mode 100644
index 67dfff6f6c..0000000000
--- a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/ConnCache.pm
+++ /dev/null
@@ -1,350 +0,0 @@
-package LWP::ConnCache;
-
-use strict;
-
-our $VERSION = '6.61';
-our $DEBUG;
-
-sub new {
- my($class, %cnf) = @_;
-
- my $total_capacity = 1;
- if (exists $cnf{total_capacity}) {
- $total_capacity = delete $cnf{total_capacity};
- }
- if (%cnf && $^W) {
- require Carp;
- Carp::carp("Unrecognised options: @{[sort keys %cnf]}")
- }
- my $self = bless { cc_conns => [] }, $class;
- $self->total_capacity($total_capacity);
- $self;
-}
-
-
-sub deposit {
- my($self, $type, $key, $conn) = @_;
- push(@{$self->{cc_conns}}, [$conn, $type, $key, time]);
- $self->enforce_limits($type);
- return;
-}
-
-
-sub withdraw {
- my($self, $type, $key) = @_;
- my $conns = $self->{cc_conns};
- for my $i (0 .. @$conns - 1) {
- my $c = $conns->[$i];
- next unless $c->[1] eq $type && $c->[2] eq $key;
- splice(@$conns, $i, 1); # remove it
- return $c->[0];
- }
- return undef;
-}
-
-
-sub total_capacity {
- my $self = shift;
- my $old = $self->{cc_limit_total};
- if (@_) {
- $self->{cc_limit_total} = shift;
- $self->enforce_limits;
- }
- $old;
-}
-
-
-sub capacity {
- my $self = shift;
- my $type = shift;
- my $old = $self->{cc_limit}{$type};
- if (@_) {
- $self->{cc_limit}{$type} = shift;
- $self->enforce_limits($type);
- }
- $old;
-}
-
-
-sub enforce_limits {
- my($self, $type) = @_;
- my $conns = $self->{cc_conns};
-
- my @types = $type ? ($type) : ($self->get_types);
- for $type (@types) {
- next unless $self->{cc_limit};
- my $limit = $self->{cc_limit}{$type};
- next unless defined $limit;
- for my $i (reverse 0 .. @$conns - 1) {
- next unless $conns->[$i][1] eq $type;
- if (--$limit < 0) {
- $self->dropping(splice(@$conns, $i, 1), "$type capacity exceeded");
- }
- }
- }
-
- if (defined(my $total = $self->{cc_limit_total})) {
- while (@$conns > $total) {
- $self->dropping(shift(@$conns), "Total capacity exceeded");
- }
- }
-}
-
-
-sub dropping {
- my($self, $c, $reason) = @_;
- print "DROPPING @$c [$reason]\n" if $DEBUG;
-}
-
-
-sub drop {
- my($self, $checker, $reason) = @_;
- if (ref($checker) ne "CODE") {
- # make it so
- if (!defined $checker) {
- $checker = sub { 1 }; # drop all of them
- }
- elsif (_looks_like_number($checker)) {
- my $age_limit = $checker;
- my $time_limit = time - $age_limit;
- $reason ||= "older than $age_limit";
- $checker = sub { $_[3] < $time_limit };
- }
- else {
- my $type = $checker;
- $reason ||= "drop $type";
- $checker = sub { $_[1] eq $type }; # match on type
- }
- }
- $reason ||= "drop";
-
- local $SIG{__DIE__}; # don't interfere with eval below
- local $@;
- my @c;
- for (@{$self->{cc_conns}}) {
- my $drop;
- eval {
- if (&$checker(@$_)) {
- $self->dropping($_, $reason);
- $drop++;
- }
- };
- push(@c, $_) unless $drop;
- }
- @{$self->{cc_conns}} = @c;
-}
-
-
-sub prune {
- my $self = shift;
- $self->drop(sub { !shift->ping }, "ping");
-}
-
-
-sub get_types {
- my $self = shift;
- my %t;
- $t{$_->[1]}++ for @{$self->{cc_conns}};
- return keys %t;
-}
-
-
-sub get_connections {
- my($self, $type) = @_;
- my @c;
- for (@{$self->{cc_conns}}) {
- push(@c, $_->[0]) if !$type || ($type && $type eq $_->[1]);
- }
- @c;
-}
-
-
-sub _looks_like_number {
- $_[0] =~ /^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/;
-}
-
-1;
-
-
-__END__
-
-=pod
-
-=head1 NAME
-
-LWP::ConnCache - Connection cache manager
-
-=head1 NOTE
-
-This module is experimental. Details of its interface is likely to
-change in the future.
-
-=head1 SYNOPSIS
-
- use LWP::ConnCache;
- my $cache = LWP::ConnCache->new;
- $cache->deposit($type, $key, $sock);
- $sock = $cache->withdraw($type, $key);
-
-=head1 DESCRIPTION
-
-The C<LWP::ConnCache> class is the standard connection cache manager
-for L<LWP::UserAgent>.
-
-=head1 METHODS
-
-The following basic methods are provided:
-
-=head2 new
-
- my $cache = LWP::ConnCache->new( %options )
-
-This method constructs a new L<LWP::ConnCache> object. The only
-option currently accepted is C<total_capacity>. If specified it
-initializes the L<LWP::ConnCache/total_capacity> option. It defaults to C<1>.
-
-=head2 total_capacity
-
- my $cap = $cache->total_capacity;
- $cache->total_capacity(0); # drop all immediately
- $cache->total_capacity(undef); # no limit
- $cache->total_capacity($number);
-
-Get/sets the number of connection that will be cached. Connections
-will start to be dropped when this limit is reached. If set to C<0>,
-then all connections are immediately dropped. If set to C<undef>,
-then there is no limit.
-
-=head2 capacity
-
- my $http_capacity = $cache->capacity('http');
- $cache->capacity('http', 2 );
-
-Get/set a limit for the number of connections of the specified type
-that can be cached. The first parameter is a short string like
-C<"http"> or C<"ftp">.
-
-=head2 drop
-
- $cache->drop(); # Drop ALL connections
- # which is just a synonym for:
- $cache->drop(sub{1}); # Drop ALL connections
- # drop all connections older than 22 seconds and add a reason for it!
- $cache->drop(22, "Older than 22 secs dropped");
- # which is just a synonym for:
- $cache->drop(sub {
- my ($conn, $type, $key, $deposit_time) = @_;
- if ($deposit_time < 22) {
- # true values drop the connection
- return 1;
- }
- # false values don't drop the connection
- return 0;
- }, "Older than 22 secs dropped" );
-
-Drop connections by some criteria. The $checker argument is a
-subroutine that is called for each connection. If the routine returns
-a TRUE value then the connection is dropped. The routine is called
-with C<($conn, $type, $key, $deposit_time)> as arguments.
-
-Shortcuts: If the C<$checker> argument is absent (or C<undef>) all cached
-connections are dropped. If the $checker is a number then all
-connections untouched that the given number of seconds or more are
-dropped. If $checker is a string then all connections of the given
-type are dropped.
-
-The C<reason> is passed on to the L<LWP::ConnCache/dropped> method.
-
-=head2 prune
-
- $cache->prune();
-
-Calling this method will drop all connections that are dead. This is
-tested by calling the L<LWP::ConnCache/ping> method on the connections. If
-the L<LWP::ConnCache/ping> method exists and returns a false value, then the
-connection is dropped.
-
-=head2 get_types
-
- my @types = $cache->get_types();
-
-This returns all the C<type> fields used for the currently cached
-connections.
-
-=head2 get_connections
-
- my @conns = $cache->get_connections(); # all connections
- my @conns = $cache->get_connections('http'); # connections for http
-
-This returns all connection objects of the specified type. If no type
-is specified then all connections are returned. In scalar context the
-number of cached connections of the specified type is returned.
-
-=head1 PROTOCOL METHODS
-
-The following methods are called by low-level protocol modules to
-try to save away connections and to get them back.
-
-=head2 deposit
-
- $cache->deposit($type, $key, $conn);
-
-This method adds a new connection to the cache. As a result, other
-already cached connections might be dropped. Multiple connections with
-the same type/key might be added.
-
-=head2 withdraw
-
- my $conn = $cache->withdraw($type, $key);
-
-This method tries to fetch back a connection that was previously
-deposited. If no cached connection with the specified $type/$key is
-found, then C<undef> is returned. There is not guarantee that a
-deposited connection can be withdrawn, as the cache manger is free to
-drop connections at any time.
-
-=head1 INTERNAL METHODS
-
-The following methods are called internally. Subclasses might want to
-override them.
-
-=head2 enforce_limits
-
- $conn->enforce_limits([$type])
-
-This method is called with after a new connection is added (deposited)
-in the cache or capacity limits are adjusted. The default
-implementation drops connections until the specified capacity limits
-are not exceeded.
-
-=head2 dropping
-
- $conn->dropping($conn_record, $reason)
-
-This method is called when a connection is dropped. The record
-belonging to the dropped connection is passed as the first argument
-and a string describing the reason for the drop is passed as the
-second argument. The default implementation makes some noise if the
-C<$LWP::ConnCache::DEBUG> variable is set and nothing more.
-
-=head1 SUBCLASSING
-
-For specialized cache policy it makes sense to subclass
-C<LWP::ConnCache> and perhaps override the L<LWP::ConnCache/deposit>,
-L<LWP::ConnCache/enforce_limits>, and L<LWP::ConnCache/dropping> methods.
-
-The object itself is a hash. Keys prefixed with C<cc_> are reserved
-for the base class.
-
-=head1 SEE ALSO
-
-L<LWP::UserAgent>
-
-=head1 COPYRIGHT
-
-Copyright 2001 Gisle Aas.
-
-This library is free software; you can redistribute it and/or
-modify it under the same terms as Perl itself.
-
-=cut
diff --git a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Debug.pm b/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Debug.pm
deleted file mode 100644
index 1e2ea15d53..0000000000
--- a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Debug.pm
+++ /dev/null
@@ -1,112 +0,0 @@
-package LWP::Debug; # legacy
-
-our $VERSION = '6.61';
-
-require Exporter;
-our @ISA = qw(Exporter);
-our @EXPORT_OK = qw(level trace debug conns);
-
-use Carp ();
-
-my @levels = qw(trace debug conns);
-our %current_level = ();
-
-sub import {
- my $pack = shift;
- my $callpkg = caller(0);
- my @symbols = ();
- my @levels = ();
- for (@_) {
- if (/^[-+]/) {
- push(@levels, $_);
- }
- else {
- push(@symbols, $_);
- }
- }
- Exporter::export($pack, $callpkg, @symbols);
- level(@levels);
-}
-
-sub level {
- for (@_) {
- if ($_ eq '+') { # all on
- # switch on all levels
- %current_level = map { $_ => 1 } @levels;
- }
- elsif ($_ eq '-') { # all off
- %current_level = ();
- }
- elsif (/^([-+])(\w+)$/) {
- $current_level{$2} = $1 eq '+';
- }
- else {
- Carp::croak("Illegal level format $_");
- }
- }
-}
-
-sub trace { _log(@_) if $current_level{'trace'}; }
-sub debug { _log(@_) if $current_level{'debug'}; }
-sub conns { _log(@_) if $current_level{'conns'}; }
-
-sub _log {
- my $msg = shift;
- $msg .= "\n" unless $msg =~ /\n$/; # ensure trailing "\n"
-
- my ($package, $filename, $line, $sub) = caller(2);
- print STDERR "$sub: $msg";
-}
-
-1;
-
-__END__
-
-=pod
-
-=head1 NAME
-
-LWP::Debug - deprecated
-
-=head1 DESCRIPTION
-
-This module has been deprecated. Please see L<LWP::ConsoleLogger> for your
-debugging needs.
-
-LWP::Debug is used to provide tracing facilities, but these are not used
-by LWP any more. The code in this module is kept around
-(undocumented) so that 3rd party code that happens to use the old
-interfaces continue to run.
-
-One useful feature that LWP::Debug provided (in an imprecise and
-troublesome way) was network traffic monitoring. The following
-section provides some hints about recommended replacements.
-
-=head2 Network traffic monitoring
-
-The best way to monitor the network traffic that LWP generates is to
-use an external TCP monitoring program. The
-L<WireShark|http://www.wireshark.org/> program is highly recommended for this.
-
-Another approach it to use a debugging HTTP proxy server and make
-LWP direct all its traffic via this one. Call C<< $ua->proxy >> to
-set it up and then just use LWP as before.
-
-For less precise monitoring needs just setting up a few simple
-handlers might do. The following example sets up handlers to dump the
-request and response objects that pass through LWP:
-
- use LWP::UserAgent;
- $ua = LWP::UserAgent->new;
- $ua->default_header('Accept-Encoding' => scalar HTTP::Message::decodable());
-
- $ua->add_handler("request_send", sub { shift->dump; return });
- $ua->add_handler("response_done", sub { shift->dump; return });
-
- $ua->get("http://www.example.com");
-
-=head1 SEE ALSO
-
-L<LWP::ConsoleLogger>, L<LWP::ConsoleLogger::Everywhere>, L<LWP::UserAgent>
-
-=cut
diff --git a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Debug/TraceHTTP.pm b/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Debug/TraceHTTP.pm
deleted file mode 100644
index a6cd44cbea..0000000000
--- a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Debug/TraceHTTP.pm
+++ /dev/null
@@ -1,29 +0,0 @@
-package LWP::Debug::TraceHTTP;
-
-# Just call:
-#
-# require LWP::Debug::TraceHTTP;
-# LWP::Protocol::implementor('http', 'LWP::Debug::TraceHTTP');
-#
-# to use this module to trace all calls to the HTTP socket object in
-# programs that use LWP.
-
-use strict;
-use parent 'LWP::Protocol::http';
-
-our $VERSION = '6.61';
-
-package # hide from PAUSE
- LWP::Debug::TraceHTTP::Socket;
-
-use Data::Dump 1.13;
-use Data::Dump::Trace qw(autowrap mcall);
-
-autowrap("LWP::Protocol::http::Socket" => "sock");
-
-sub new {
- my $class = shift;
- return mcall("LWP::Protocol::http::Socket" => "new", undef, @_);
-}
-
-1;
diff --git a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/DebugFile.pm b/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/DebugFile.pm
deleted file mode 100644
index 27f3dbb228..0000000000
--- a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/DebugFile.pm
+++ /dev/null
@@ -1,7 +0,0 @@
-package LWP::DebugFile;
-
-our $VERSION = '6.61';
-
-# legacy stub
-
-1;
diff --git a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/MemberMixin.pm b/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/MemberMixin.pm
deleted file mode 100644
index a5a9e7599b..0000000000
--- a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/MemberMixin.pm
+++ /dev/null
@@ -1,48 +0,0 @@
-package LWP::MemberMixin;
-
-our $VERSION = '6.61';
-
-sub _elem {
- my $self = shift;
- my $elem = shift;
- my $old = $self->{$elem};
- $self->{$elem} = shift if @_;
- return $old;
-}
-
-1;
-
-__END__
-
-=pod
-
-=head1 NAME
-
-LWP::MemberMixin - Member access mixin class
-
-=head1 SYNOPSIS
-
- package Foo;
- use parent qw(LWP::MemberMixin);
-
-=head1 DESCRIPTION
-
-A mixin class to get methods that provide easy access to member
-variables in the C<%$self>.
-Ideally there should be better Perl language support for this.
-
-=head1 METHODS
-
-There is only one method provided:
-
-=head2 _elem
-
- _elem($elem [, $val])
-
-Internal method to get/set the value of member variable
-C<$elem>. If C<$val> is present it is used as the new value
-for the member variable. If it is not present the current
-value is not touched. In both cases the previous value of
-the member variable is returned.
-
-=cut
diff --git a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol.pm b/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol.pm
deleted file mode 100644
index 1d656cf850..0000000000
--- a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol.pm
+++ /dev/null
@@ -1,313 +0,0 @@
-package LWP::Protocol;
-
-use parent 'LWP::MemberMixin';
-
-our $VERSION = '6.61';
-
-use strict;
-use Carp ();
-use HTTP::Status ();
-use HTTP::Response ();
-use Try::Tiny qw(try catch);
-
-my %ImplementedBy = (); # scheme => classname
-
-sub new
-{
- my($class, $scheme, $ua) = @_;
-
- my $self = bless {
- scheme => $scheme,
- ua => $ua,
-
- # historical/redundant
- max_size => $ua->{max_size},
- }, $class;
-
- $self;
-}
-
-
-sub create
-{
- my($scheme, $ua) = @_;
- my $impclass = LWP::Protocol::implementor($scheme) or
- Carp::croak("Protocol scheme '$scheme' is not supported");
-
- # hand-off to scheme specific implementation sub-class
- my $protocol = $impclass->new($scheme, $ua);
-
- return $protocol;
-}
-
-
-sub implementor
-{
- my($scheme, $impclass) = @_;
-
- if ($impclass) {
- $ImplementedBy{$scheme} = $impclass;
- }
- my $ic = $ImplementedBy{$scheme};
- return $ic if $ic;
-
- return '' unless $scheme =~ /^([.+\-\w]+)$/; # check valid URL schemes
- $scheme = $1; # untaint
- $scheme =~ tr/.+-/_/; # make it a legal module name
-
- # scheme not yet known, look for a 'use'd implementation
- $ic = "LWP::Protocol::$scheme"; # default location
- $ic = "LWP::Protocol::nntp" if $scheme eq 'news'; #XXX ugly hack
- no strict 'refs';
- # check we actually have one for the scheme:
- unless (@{"${ic}::ISA"}) {
- # try to autoload it
- try {
- (my $class = $ic) =~ s{::}{/}g;
- $class .= '.pm' unless $class =~ /\.pm$/;
- require $class;
- }
- catch {
- my $error = $_;
- if ($error =~ /Can't locate/) {
- $ic = '';
- }
- else {
- die "$error\n";
- }
- };
- }
- $ImplementedBy{$scheme} = $ic if $ic;
- $ic;
-}
-
-
-sub request
-{
- my($self, $request, $proxy, $arg, $size, $timeout) = @_;
- Carp::croak('LWP::Protocol::request() needs to be overridden in subclasses');
-}
-
-
-# legacy
-sub timeout { shift->_elem('timeout', @_); }
-sub max_size { shift->_elem('max_size', @_); }
-
-
-sub collect
-{
- my ($self, $arg, $response, $collector) = @_;
- my $content;
- my($ua, $max_size) = @{$self}{qw(ua max_size)};
-
- # This can't be moved to Try::Tiny due to the closures within causing
- # leaks on any version of Perl prior to 5.18.
- # https://perl5.git.perl.org/perl.git/commitdiff/a0d2bbd5c
- my $error = do { #catch
- local $@;
- local $\; # protect the print below from surprises
- eval { # try
- if (!defined($arg) || !$response->is_success) {
- $response->{default_add_content} = 1;
- }
- elsif (!ref($arg) && length($arg)) {
- open(my $fh, ">", $arg) or die "Can't write to '$arg': $!";
- binmode($fh);
- push(@{$response->{handlers}{response_data}}, {
- callback => sub {
- print $fh $_[3] or die "Can't write to '$arg': $!";
- 1;
- },
- });
- push(@{$response->{handlers}{response_done}}, {
- callback => sub {
- close($fh) or die "Can't write to '$arg': $!";
- undef($fh);
- },
- });
- }
- elsif (ref($arg) eq 'CODE') {
- push(@{$response->{handlers}{response_data}}, {
- callback => sub {
- &$arg($_[3], $_[0], $self);
- 1;
- },
- });
- }
- else {
- die "Unexpected collect argument '$arg'";
- }
-
- $ua->run_handlers("response_header", $response);
-
- if (delete $response->{default_add_content}) {
- push(@{$response->{handlers}{response_data}}, {
- callback => sub {
- $_[0]->add_content($_[3]);
- 1;
- },
- });
- }
-
-
- my $content_size = 0;
- my $length = $response->content_length;
- my %skip_h;
-
- while ($content = &$collector, length $$content) {
- for my $h ($ua->handlers("response_data", $response)) {
- next if $skip_h{$h};
- unless ($h->{callback}->($response, $ua, $h, $$content)) {
- # XXX remove from $response->{handlers}{response_data} if present
- $skip_h{$h}++;
- }
- }
- $content_size += length($$content);
- $ua->progress(($length ? ($content_size / $length) : "tick"), $response);
- if (defined($max_size) && $content_size > $max_size) {
- $response->push_header("Client-Aborted", "max_size");
- last;
- }
- }
- 1;
- };
- $@;
- };
-
- if ($error) {
- chomp($error);
- $response->push_header('X-Died' => $error);
- $response->push_header("Client-Aborted", "die");
- };
- delete $response->{handlers}{response_data};
- delete $response->{handlers} unless %{$response->{handlers}};
- return $response;
-}
-
-
-sub collect_once
-{
- my($self, $arg, $response) = @_;
- my $content = \ $_[3];
- my $first = 1;
- $self->collect($arg, $response, sub {
- return $content if $first--;
- return \ "";
- });
-}
-
-1;
-
-
-__END__
-
-=pod
-
-=head1 NAME
-
-LWP::Protocol - Base class for LWP protocols
-
-=head1 SYNOPSIS
-
- package LWP::Protocol::foo;
- use parent qw(LWP::Protocol);
-
-=head1 DESCRIPTION
-
-This class is used as the base class for all protocol implementations
-supported by the LWP library.
-
-When creating an instance of this class using
-C<LWP::Protocol::create($url)>, and you get an initialized subclass
-appropriate for that access method. In other words, the
-L<LWP::Protocol/create> function calls the constructor for one of its
-subclasses.
-
-All derived C<LWP::Protocol> classes need to override the C<request()>
-method which is used to service a request. The overridden method can
-make use of the C<collect()> method to collect together chunks of data
-as it is received.
-
-=head1 METHODS
-
-The following methods and functions are provided:
-
-=head2 new
-
- my $prot = LWP::Protocol->new();
-
-The LWP::Protocol constructor is inherited by subclasses. As this is a
-virtual base class this method should B<not> be called directly.
-
-=head2 create
-
- my $prot = LWP::Protocol::create($scheme)
-
-Create an object of the class implementing the protocol to handle the
-given scheme. This is a function, not a method. It is more an object
-factory than a constructor. This is the function user agents should
-use to access protocols.
-
-=head2 implementor
-
- my $class = LWP::Protocol::implementor($scheme, [$class])
-
-Get and/or set implementor class for a scheme. Returns C<''> if the
-specified scheme is not supported.
-
-=head2 request
-
- $response = $protocol->request($request, $proxy, undef);
- $response = $protocol->request($request, $proxy, '/tmp/sss');
- $response = $protocol->request($request, $proxy, \&callback, 1024);
-
-Dispatches a request over the protocol, and returns a response
-object. This method needs to be overridden in subclasses. Refer to
-L<LWP::UserAgent> for description of the arguments.
-
-=head2 collect
-
- my $res = $prot->collect(undef, $response, $collector); # stored in $response
- my $res = $prot->collect($filename, $response, $collector);
- my $res = $prot->collect(sub { ... }, $response, $collector);
-
-Collect the content of a request, and process it appropriately into a scalar,
-file, or by calling a callback. If the first parameter is undefined, then the
-content is stored within the C<$response>. If it's a simple scalar, then it's
-interpreted as a file name and the content is written to this file. If it's a
-code reference, then content is passed to this routine.
-
-The collector is a routine that will be called and which is
-responsible for returning pieces (as ref to scalar) of the content to
-process. The C<$collector> signals C<EOF> by returning a reference to an
-empty string.
-
-The return value is the L<HTTP::Response> object reference.
-
-B<Note:> We will only use the callback or file argument if
-C<< $response->is_success() >>. This avoids sending content data for
-redirects and authentication responses to the callback which would be
-confusing.
-
-=head2 collect_once
-
- $prot->collect_once($arg, $response, $content)
-
-Can be called when the whole response content is available as content. This
-will invoke L<LWP::Protocol/collect> with a collector callback that
-returns a reference to C<$content> the first time and an empty string the
-next.
-
-=head1 SEE ALSO
-
-Inspect the F<LWP/Protocol/file.pm> and F<LWP/Protocol/http.pm> files
-for examples of usage.
-
-=head1 COPYRIGHT
-
-Copyright 1995-2001 Gisle Aas.
-
-This library is free software; you can redistribute it and/or
-modify it under the same terms as Perl itself.
-
-=cut
diff --git a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/cpan.pm b/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/cpan.pm
deleted file mode 100644
index 90ced43d06..0000000000
--- a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/cpan.pm
+++ /dev/null
@@ -1,72 +0,0 @@
-package LWP::Protocol::cpan;
-
-use strict;
-
-use parent qw(LWP::Protocol);
-
-our $VERSION = '6.61';
-
-require URI;
-require HTTP::Status;
-require HTTP::Response;
-
-our $CPAN;
-
-unless ($CPAN) {
- # Try to find local CPAN mirror via $CPAN::Config
- eval {
- require CPAN::Config;
- if($CPAN::Config) {
- my $urls = $CPAN::Config->{urllist};
- if (ref($urls) eq "ARRAY") {
- my $file;
- for (@$urls) {
- if (/^file:/) {
- $file = $_;
- last;
- }
- }
-
- if ($file) {
- $CPAN = $file;
- }
- else {
- $CPAN = $urls->[0];
- }
- }
- }
- };
-
- $CPAN ||= "http://cpan.org/"; # last resort
-}
-
-# ensure that we don't chop of last part
-$CPAN .= "/" unless $CPAN =~ m,/$,;
-
-
-sub request {
- my($self, $request, $proxy, $arg, $size) = @_;
- # check proxy
- if (defined $proxy)
- {
- return HTTP::Response->new(HTTP::Status::RC_BAD_REQUEST,
- 'You can not proxy with cpan');
- }
-
- # check method
- my $method = $request->method;
- unless ($method eq 'GET' || $method eq 'HEAD') {
- return HTTP::Response->new(HTTP::Status::RC_BAD_REQUEST,
- 'Library does not allow method ' .
- "$method for 'cpan:' URLs");
- }
-
- my $path = $request->uri->path;
- $path =~ s,^/,,;
-
- my $response = HTTP::Response->new(HTTP::Status::RC_FOUND);
- $response->header("Location" => URI->new_abs($path, $CPAN));
- $response;
-}
-
-1;
diff --git a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/data.pm b/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/data.pm
deleted file mode 100644
index a0461b5e41..0000000000
--- a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/data.pm
+++ /dev/null
@@ -1,52 +0,0 @@
-package LWP::Protocol::data;
-
-# Implements access to data:-URLs as specified in RFC 2397
-
-use strict;
-
-our $VERSION = '6.61';
-
-require HTTP::Response;
-require HTTP::Status;
-
-use parent qw(LWP::Protocol);
-
-use HTTP::Date qw(time2str);
-require LWP; # needs version number
-
-sub request
-{
- my($self, $request, $proxy, $arg, $size) = @_;
-
- # check proxy
- if (defined $proxy)
- {
- return HTTP::Response->new( HTTP::Status::RC_BAD_REQUEST,
- 'You can not proxy with data');
- }
-
- # check method
- my $method = $request->method;
- unless ($method eq 'GET' || $method eq 'HEAD') {
- return HTTP::Response->new( HTTP::Status::RC_BAD_REQUEST,
- 'Library does not allow method ' .
- "$method for 'data:' URLs");
- }
-
- my $url = $request->uri;
- my $response = HTTP::Response->new( HTTP::Status::RC_OK, "Document follows");
-
- my $media_type = $url->media_type;
-
- my $data = $url->data;
- $response->header('Content-Type' => $media_type,
- 'Content-Length' => length($data),
- 'Date' => time2str(time),
- 'Server' => "libwww-perl-internal/$LWP::VERSION"
- );
-
- $data = "" if $method eq "HEAD";
- return $self->collect_once($arg, $response, $data);
-}
-
-1;
diff --git a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/file.pm b/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/file.pm
deleted file mode 100644
index 37be55d76f..0000000000
--- a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/file.pm
+++ /dev/null
@@ -1,147 +0,0 @@
-package LWP::Protocol::file;
-
-use parent qw(LWP::Protocol);
-
-use strict;
-
-our $VERSION = '6.61';
-
-require LWP::MediaTypes;
-require HTTP::Request;
-require HTTP::Response;
-require HTTP::Status;
-require HTTP::Date;
-
-
-sub request
-{
- my($self, $request, $proxy, $arg, $size) = @_;
-
- $size = 4096 unless defined $size and $size > 0;
-
- # check proxy
- if (defined $proxy)
- {
- return HTTP::Response->new( HTTP::Status::RC_BAD_REQUEST,
- 'You can not proxy through the filesystem');
- }
-
- # check method
- my $method = $request->method;
- unless ($method eq 'GET' || $method eq 'HEAD') {
- return HTTP::Response->new( HTTP::Status::RC_BAD_REQUEST,
- 'Library does not allow method ' .
- "$method for 'file:' URLs");
- }
-
- # check url
- my $url = $request->uri;
-
- my $scheme = $url->scheme;
- if ($scheme ne 'file') {
- return HTTP::Response->new( HTTP::Status::RC_INTERNAL_SERVER_ERROR,
- "LWP::Protocol::file::request called for '$scheme'");
- }
-
- # URL OK, look at file
- my $path = $url->file;
-
- # test file exists and is readable
- unless (-e $path) {
- return HTTP::Response->new( HTTP::Status::RC_NOT_FOUND,
- "File `$path' does not exist");
- }
- unless (-r _) {
- return HTTP::Response->new( HTTP::Status::RC_FORBIDDEN,
- 'User does not have read permission');
- }
-
- # looks like file exists
- my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$filesize,
- $atime,$mtime,$ctime,$blksize,$blocks)
- = stat(_);
-
- # XXX should check Accept headers?
-
- # check if-modified-since
- my $ims = $request->header('If-Modified-Since');
- if (defined $ims) {
- my $time = HTTP::Date::str2time($ims);
- if (defined $time and $time >= $mtime) {
- return HTTP::Response->new( HTTP::Status::RC_NOT_MODIFIED,
- "$method $path");
- }
- }
-
- # Ok, should be an OK response by now...
- my $response = HTTP::Response->new( HTTP::Status::RC_OK );
-
- # fill in response headers
- $response->header('Last-Modified', HTTP::Date::time2str($mtime));
-
- if (-d _) { # If the path is a directory, process it
- # generate the HTML for directory
- opendir(D, $path) or
- return HTTP::Response->new( HTTP::Status::RC_INTERNAL_SERVER_ERROR,
- "Cannot read directory '$path': $!");
- my(@files) = sort readdir(D);
- closedir(D);
-
- # Make directory listing
- require URI::Escape;
- require HTML::Entities;
- my $pathe = $path . ( $^O eq 'MacOS' ? ':' : '/');
- for (@files) {
- my $furl = URI::Escape::uri_escape($_);
- if ( -d "$pathe$_" ) {
- $furl .= '/';
- $_ .= '/';
- }
- my $desc = HTML::Entities::encode($_);
- $_ = qq{<LI><A HREF="$furl">$desc</A>};
- }
- # Ensure that the base URL is "/" terminated
- my $base = $url->clone;
- unless ($base->path =~ m|/$|) {
- $base->path($base->path . "/");
- }
- my $html = join("\n",
- "<HTML>\n<HEAD>",
- "<TITLE>Directory $path</TITLE>",
- "<BASE HREF=\"$base\">",
- "</HEAD>\n<BODY>",
- "<H1>Directory listing of $path</H1>",
- "<UL>", @files, "</UL>",
- "</BODY>\n</HTML>\n");
-
- $response->header('Content-Type', 'text/html');
- $response->header('Content-Length', length $html);
- $html = "" if $method eq "HEAD";
-
- return $self->collect_once($arg, $response, $html);
-
- }
-
- # path is a regular file
- $response->header('Content-Length', $filesize);
- LWP::MediaTypes::guess_media_type($path, $response);
-
- # read the file
- if ($method ne "HEAD") {
- open(my $fh, '<', $path) or return new
- HTTP::Response(HTTP::Status::RC_INTERNAL_SERVER_ERROR,
- "Cannot read file '$path': $!");
- binmode($fh);
- $response = $self->collect($arg, $response, sub {
- my $content = "";
- my $bytes = sysread($fh, $content, $size);
- return \$content if $bytes > 0;
- return \ "";
- });
- close($fh);
- }
-
- $response;
-}
-
-1;
diff --git a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/ftp.pm b/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/ftp.pm
deleted file mode 100644
index a82d527345..0000000000
--- a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/ftp.pm
+++ /dev/null
@@ -1,555 +0,0 @@
-package LWP::Protocol::ftp;
-
-# Implementation of the ftp protocol (RFC 959). We let the Net::FTP
-# package do all the dirty work.
-use parent qw(LWP::Protocol);
-use strict;
-
-our $VERSION = '6.61';
-
-use Carp ();
-use HTTP::Status ();
-use HTTP::Negotiate ();
-use HTTP::Response ();
-use LWP::MediaTypes ();
-use File::Listing ();
-
-
-{
-
- package # hide from PAUSE
- LWP::Protocol::MyFTP;
-
- use strict;
- use parent qw(Net::FTP);
-
- sub new {
- my $class = shift;
-
- my $self = $class->SUPER::new(@_) || return undef;
-
- my $mess = $self->message; # welcome message
- $mess =~ s|\n.*||s; # only first line left
- $mess =~ s|\s*ready\.?$||;
-
- # Make the version number more HTTP like
- $mess =~ s|\s*\(Version\s*|/| and $mess =~ s|\)$||;
- ${*$self}{myftp_server} = $mess;
-
- #$response->header("Server", $mess);
-
- $self;
- }
-
- sub http_server {
- my $self = shift;
- ${*$self}{myftp_server};
- }
-
- sub home {
- my $self = shift;
- my $old = ${*$self}{myftp_home};
- if (@_) {
- ${*$self}{myftp_home} = shift;
- }
- $old;
- }
-
- sub go_home {
- my $self = shift;
- $self->cwd(${*$self}{myftp_home});
- }
-
- sub request_count {
- my $self = shift;
- ++${*$self}{myftp_reqcount};
- }
-
- sub ping {
- my $self = shift;
- return $self->go_home;
- }
-}
-
-sub _connect {
- my ($self, $host, $port, $user, $account, $password, $timeout) = @_;
-
- my $key;
- my $conn_cache = $self->{ua}{conn_cache};
- if ($conn_cache) {
- $key = "$host:$port:$user";
- $key .= ":$account" if defined($account);
- if (my $ftp = $conn_cache->withdraw("ftp", $key)) {
- if ($ftp->ping) {
-
- # save it again
- $conn_cache->deposit("ftp", $key, $ftp);
- return $ftp;
- }
- }
- }
-
- # try to make a connection
- my $ftp = LWP::Protocol::MyFTP->new(
- $host,
- Port => $port,
- Timeout => $timeout,
- LocalAddr => $self->{ua}{local_address},
- );
-
- # XXX Should be some what to pass on 'Passive' (header??)
- unless ($ftp) {
- $@ =~ s/^Net::FTP: //;
- return HTTP::Response->new(HTTP::Status::RC_INTERNAL_SERVER_ERROR, $@);
- }
-
- unless ($ftp->login($user, $password, $account)) {
-
- # Unauthorized. Let's fake a RC_UNAUTHORIZED response
- my $mess = scalar($ftp->message);
- $mess =~ s/\n$//;
- my $res = HTTP::Response->new(HTTP::Status::RC_UNAUTHORIZED, $mess);
- $res->header("Server", $ftp->http_server);
- $res->header("WWW-Authenticate", qq(Basic Realm="FTP login"));
- return $res;
- }
-
- my $home = $ftp->pwd;
- $ftp->home($home);
-
- $conn_cache->deposit("ftp", $key, $ftp) if $conn_cache;
-
- return $ftp;
-}
-
-
-sub request {
- my ($self, $request, $proxy, $arg, $size, $timeout) = @_;
-
- $size = 4096 unless $size;
-
- # check proxy
- if (defined $proxy) {
- return HTTP::Response->new(HTTP::Status::RC_BAD_REQUEST,
- 'You can not proxy through the ftp');
- }
-
- my $url = $request->uri;
- if ($url->scheme ne 'ftp') {
- my $scheme = $url->scheme;
- return HTTP::Response->new(HTTP::Status::RC_INTERNAL_SERVER_ERROR,
- "LWP::Protocol::ftp::request called for '$scheme'");
- }
-
- # check method
- my $method = $request->method;
-
- unless ($method eq 'GET' || $method eq 'HEAD' || $method eq 'PUT') {
- return HTTP::Response->new(HTTP::Status::RC_BAD_REQUEST,
- 'Library does not allow method ' . "$method for 'ftp:' URLs");
- }
-
- my $host = $url->host;
- my $port = $url->port;
- my $user = $url->user;
- my $password = $url->password;
-
- # If a basic authorization header is present than we prefer these over
- # the username/password specified in the URL.
- {
- my ($u, $p) = $request->authorization_basic;
- if (defined $u) {
- $user = $u;
- $password = $p;
- }
- }
-
- # We allow the account to be specified in the "Account" header
- my $account = $request->header('Account');
-
- my $ftp
- = $self->_connect($host, $port, $user, $account, $password, $timeout);
- return $ftp if ref($ftp) eq "HTTP::Response"; # ugh!
-
- # Create an initial response object
- my $response = HTTP::Response->new(HTTP::Status::RC_OK, "OK");
- $response->header(Server => $ftp->http_server);
- $response->header('Client-Request-Num' => $ftp->request_count);
- $response->request($request);
-
- # Get & fix the path
- my @path = grep {length} $url->path_segments;
- my $remote_file = pop(@path);
- $remote_file = '' unless defined $remote_file;
-
- my $type;
- if (ref $remote_file) {
- my @params;
- ($remote_file, @params) = @$remote_file;
- for (@params) {
- $type = $_ if s/^type=//;
- }
- }
-
- if ($type && $type eq 'a') {
- $ftp->ascii;
- }
- else {
- $ftp->binary;
- }
-
- for (@path) {
- unless ($ftp->cwd($_)) {
- return HTTP::Response->new(HTTP::Status::RC_NOT_FOUND,
- "Can't chdir to $_");
- }
- }
-
- if ($method eq 'GET' || $method eq 'HEAD') {
- if (my $mod_time = $ftp->mdtm($remote_file)) {
- $response->last_modified($mod_time);
- if (my $ims = $request->if_modified_since) {
- if ($mod_time <= $ims) {
- $response->code(HTTP::Status::RC_NOT_MODIFIED);
- $response->message("Not modified");
- return $response;
- }
- }
- }
-
- # We'll use this later to abort the transfer if necessary.
- # if $max_size is defined, we need to abort early. Otherwise, it's
- # a normal transfer
- my $max_size = undef;
-
- # Set resume location, if the client requested it
- if ($request->header('Range') && $ftp->supported('REST')) {
- my $range_info = $request->header('Range');
-
- # Change bytes=2772992-6781209 to just 2772992
- my ($start_byte, $end_byte) = $range_info =~ /.*=\s*(\d+)-(\d+)?/;
- if (defined $start_byte && !defined $end_byte) {
-
- # open range -- only the start is specified
-
- $ftp->restart($start_byte);
-
- # don't define $max_size, we don't want to abort early
- }
- elsif (defined $start_byte
- && defined $end_byte
- && $start_byte >= 0
- && $end_byte >= $start_byte)
- {
-
- $ftp->restart($start_byte);
- $max_size = $end_byte - $start_byte;
- }
- else {
-
- return HTTP::Response->new(HTTP::Status::RC_BAD_REQUEST,
- 'Incorrect syntax for Range request');
- }
- }
- elsif ($request->header('Range') && !$ftp->supported('REST')) {
- return HTTP::Response->new(HTTP::Status::RC_NOT_IMPLEMENTED,
- "Server does not support resume."
- );
- }
-
- my $data; # the data handle
- if (length($remote_file) and $data = $ftp->retr($remote_file)) {
- my ($type, @enc) = LWP::MediaTypes::guess_media_type($remote_file);
- $response->header('Content-Type', $type) if $type;
- for (@enc) {
- $response->push_header('Content-Encoding', $_);
- }
- my $mess = $ftp->message;
- if ($mess =~ /\((\d+)\s+bytes\)/) {
- $response->header('Content-Length', "$1");
- }
-
- if ($method ne 'HEAD') {
-
- # Read data from server
- $response = $self->collect(
- $arg,
- $response,
- sub {
- my $content = '';
- my $result = $data->read($content, $size);
-
- # Stop early if we need to.
- if (defined $max_size) {
-
- # We need an interface to Net::FTP::dataconn for getting
- # the number of bytes already read
- my $bytes_received = $data->bytes_read();
-
- # We were already over the limit. (Should only happen
- # once at the end.)
- if ($bytes_received - length($content) > $max_size)
- {
- $content = '';
- }
-
- # We just went over the limit
- elsif ($bytes_received > $max_size) {
-
- # Trim content
- $content = substr($content, 0,
- $max_size
- - ($bytes_received - length($content)));
- }
-
- # We're under the limit
- else {
- }
- }
-
- return \$content;
- }
- );
- }
-
- # abort is needed for HEAD, it's == close if the transfer has
- # already completed.
- unless ($data->abort) {
-
- # Something did not work too well. Note that we treat
- # responses to abort() with code 0 in case of HEAD as ok
- # (at least wu-ftpd 2.6.1(1) does that).
- if ($method ne 'HEAD' || $ftp->code != 0) {
- $response->code(HTTP::Status::RC_INTERNAL_SERVER_ERROR);
- $response->message("FTP close response: "
- . $ftp->code . " "
- . $ftp->message);
- }
- }
- }
- elsif (!length($remote_file) || ($ftp->code >= 400 && $ftp->code < 600))
- {
- # not a plain file, try to list instead
- if (length($remote_file) && !$ftp->cwd($remote_file)) {
- return HTTP::Response->new(HTTP::Status::RC_NOT_FOUND,
- "File '$remote_file' not found"
- );
- }
-
- # It should now be safe to try to list the directory
- my @lsl = $ftp->dir;
-
- # Try to figure out if the user want us to convert the
- # directory listing to HTML.
- my @variants = (
- ['html', 0.60, 'text/html'],
- ['dir', 1.00, 'text/ftp-dir-listing']
- );
-
- #$HTTP::Negotiate::DEBUG=1;
- my $prefer = HTTP::Negotiate::choose(\@variants, $request);
-
- my $content = '';
-
- if (!defined($prefer)) {
- return HTTP::Response->new(HTTP::Status::RC_NOT_ACCEPTABLE,
- "Neither HTML nor directory listing wanted");
- }
- elsif ($prefer eq 'html') {
- $response->header('Content-Type' => 'text/html');
- $content = "<HEAD><TITLE>File Listing</TITLE>\n";
- my $base = $request->uri->clone;
- my $path = $base->path;
- $base->path("$path/") unless $path =~ m|/$|;
- $content .= qq(<BASE HREF="$base">\n</HEAD>\n);
- $content .= "<BODY>\n<UL>\n";
- for (File::Listing::parse_dir(\@lsl, 'GMT')) {
- my ($name, $type, $size, $mtime, $mode) = @$_;
- $content .= qq( <LI> <a href="$name">$name</a>);
- $content .= " $size bytes" if $type eq 'f';
- $content .= "\n";
- }
- $content .= "</UL></body>\n";
- }
- else {
- $response->header('Content-Type', 'text/ftp-dir-listing');
- $content = join("\n", @lsl, '');
- }
-
- $response->header('Content-Length', length($content));
-
- if ($method ne 'HEAD') {
- $response = $self->collect_once($arg, $response, $content);
- }
- }
- else {
- my $res = HTTP::Response->new(HTTP::Status::RC_BAD_REQUEST,
- "FTP return code " . $ftp->code);
- $res->content_type("text/plain");
- $res->content($ftp->message);
- return $res;
- }
- }
- elsif ($method eq 'PUT') {
-
- # method must be PUT
- unless (length($remote_file)) {
- return HTTP::Response->new(HTTP::Status::RC_BAD_REQUEST,
- "Must have a file name to PUT to"
- );
- }
- my $data;
- if ($data = $ftp->stor($remote_file)) {
- my $content = $request->content;
- my $bytes = 0;
- if (defined $content) {
- if (ref($content) eq 'SCALAR') {
- $bytes = $data->write($$content, length($$content));
- }
- elsif (ref($content) eq 'CODE') {
- my ($buf, $n);
- while (length($buf = &$content)) {
- $n = $data->write($buf, length($buf));
- last unless $n;
- $bytes += $n;
- }
- }
- elsif (!ref($content)) {
- if (defined $content && length($content)) {
- $bytes = $data->write($content, length($content));
- }
- }
- else {
- die "Bad content";
- }
- }
- $data->close;
-
- $response->code(HTTP::Status::RC_CREATED);
- $response->header('Content-Type', 'text/plain');
- $response->content("$bytes bytes stored as $remote_file on $host\n")
-
- }
- else {
- my $res = HTTP::Response->new(HTTP::Status::RC_BAD_REQUEST,
- "FTP return code " . $ftp->code);
- $res->content_type("text/plain");
- $res->content($ftp->message);
- return $res;
- }
- }
- else {
- return HTTP::Response->new(HTTP::Status::RC_BAD_REQUEST,
- "Illegal method $method");
- }
-
- $response;
-}
-
-1;
-
-__END__
-
-# This is what RFC 1738 has to say about FTP access:
-# --------------------------------------------------
-#
-# 3.2. FTP
-#
-# The FTP URL scheme is used to designate files and directories on
-# Internet hosts accessible using the FTP protocol (RFC959).
-#
-# A FTP URL follow the syntax described in Section 3.1. If :<port> is
-# omitted, the port defaults to 21.
-#
-# 3.2.1. FTP Name and Password
-#
-# A user name and password may be supplied; they are used in the ftp
-# "USER" and "PASS" commands after first making the connection to the
-# FTP server. If no user name or password is supplied and one is
-# requested by the FTP server, the conventions for "anonymous" FTP are
-# to be used, as follows:
-#
-# The user name "anonymous" is supplied.
-#
-# The password is supplied as the Internet e-mail address
-# of the end user accessing the resource.
-#
-# If the URL supplies a user name but no password, and the remote
-# server requests a password, the program interpreting the FTP URL
-# should request one from the user.
-#
-# 3.2.2. FTP url-path
-#
-# The url-path of a FTP URL has the following syntax:
-#
-# <cwd1>/<cwd2>/.../<cwdN>/<name>;type=<typecode>
-#
-# Where <cwd1> through <cwdN> and <name> are (possibly encoded) strings
-# and <typecode> is one of the characters "a", "i", or "d". The part
-# ";type=<typecode>" may be omitted. The <cwdx> and <name> parts may be
-# empty. The whole url-path may be omitted, including the "/"
-# delimiting it from the prefix containing user, password, host, and
-# port.
-#
-# The url-path is interpreted as a series of FTP commands as follows:
-#
-# Each of the <cwd> elements is to be supplied, sequentially, as the
-# argument to a CWD (change working directory) command.
-#
-# If the typecode is "d", perform a NLST (name list) command with
-# <name> as the argument, and interpret the results as a file
-# directory listing.
-#
-# Otherwise, perform a TYPE command with <typecode> as the argument,
-# and then access the file whose name is <name> (for example, using
-# the RETR command.)
-#
-# Within a name or CWD component, the characters "/" and ";" are
-# reserved and must be encoded. The components are decoded prior to
-# their use in the FTP protocol. In particular, if the appropriate FTP
-# sequence to access a particular file requires supplying a string
-# containing a "/" as an argument to a CWD or RETR command, it is
-# necessary to encode each "/".
-#
-# For example, the URL <URL:ftp://myname@host.dom/%2Fetc/motd> is
-# interpreted by FTP-ing to "host.dom", logging in as "myname"
-# (prompting for a password if it is asked for), and then executing
-# "CWD /etc" and then "RETR motd". This has a different meaning from
-# <URL:ftp://myname@host.dom/etc/motd> which would "CWD etc" and then
-# "RETR motd"; the initial "CWD" might be executed relative to the
-# default directory for "myname". On the other hand,
-# <URL:ftp://myname@host.dom//etc/motd>, would "CWD " with a null
-# argument, then "CWD etc", and then "RETR motd".
-#
-# FTP URLs may also be used for other operations; for example, it is
-# possible to update a file on a remote file server, or infer
-# information about it from the directory listings. The mechanism for
-# doing so is not spelled out here.
-#
-# 3.2.3. FTP Typecode is Optional
-#
-# The entire ;type=<typecode> part of a FTP URL is optional. If it is
-# omitted, the client program interpreting the URL must guess the
-# appropriate mode to use. In general, the data content type of a file
-# can only be guessed from the name, e.g., from the suffix of the name;
-# the appropriate type code to be used for transfer of the file can
-# then be deduced from the data content of the file.
-#
-# 3.2.4 Hierarchy
-#
-# For some file systems, the "/" used to denote the hierarchical
-# structure of the URL corresponds to the delimiter used to construct a
-# file name hierarchy, and thus, the filename will look similar to the
-# URL path. This does NOT mean that the URL is a Unix filename.
-#
-# 3.2.5. Optimization
-#
-# Clients accessing resources via FTP may employ additional heuristics
-# to optimize the interaction. For some FTP servers, for example, it
-# may be reasonable to keep the control connection open while accessing
-# multiple URLs from the same server. However, there is no common
-# hierarchical model to the FTP protocol, so if a directory change
-# command has been given, it is impossible in general to deduce what
-# sequence should be given to navigate to another directory for a
-# second retrieval, if the paths are different. The only reliable
-# algorithm is to disconnect and reestablish the control connection.
diff --git a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/gopher.pm b/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/gopher.pm
deleted file mode 100644
index 1b46df4a07..0000000000
--- a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/gopher.pm
+++ /dev/null
@@ -1,213 +0,0 @@
-package LWP::Protocol::gopher;
-
-# Implementation of the gopher protocol (RFC 1436)
-#
-# This code is based on 'wwwgopher.pl,v 0.10 1994/10/17 18:12:34 shelden'
-# which in turn is a vastly modified version of Oscar's http'get()
-# dated 28/3/94 in <ftp://cui.unige.ch/PUBLIC/oscar/scripts/http.pl>
-# including contributions from Marc van Heyningen and Martijn Koster.
-
-use strict;
-
-our $VERSION = '6.61';
-
-require HTTP::Response;
-require HTTP::Status;
-require IO::Socket;
-require IO::Select;
-
-use parent qw(LWP::Protocol);
-
-
-my %gopher2mimetype = (
- '0' => 'text/plain', # 0 file
- '1' => 'text/html', # 1 menu
- # 2 CSO phone-book server
- # 3 Error
- '4' => 'application/mac-binhex40', # 4 BinHexed Macintosh file
- '5' => 'application/zip', # 5 DOS binary archive of some sort
- '6' => 'application/octet-stream', # 6 UNIX uuencoded file.
- '7' => 'text/html', # 7 Index-Search server
- # 8 telnet session
- '9' => 'application/octet-stream', # 9 binary file
- 'h' => 'text/html', # html
- 'g' => 'image/gif', # gif
- 'I' => 'image/*', # some kind of image
-);
-
-my %gopher2encoding = (
- '6' => 'x_uuencode', # 6 UNIX uuencoded file.
-);
-
-sub request
-{
- my($self, $request, $proxy, $arg, $size, $timeout) = @_;
-
- $size = 4096 unless $size;
-
- # check proxy
- if (defined $proxy) {
- return HTTP::Response->new(HTTP::Status::RC_BAD_REQUEST,
- 'You can not proxy through the gopher');
- }
-
- my $url = $request->uri;
- die "bad scheme" if $url->scheme ne 'gopher';
-
-
- my $method = $request->method;
- unless ($method eq 'GET' || $method eq 'HEAD') {
- return HTTP::Response->new(HTTP::Status::RC_BAD_REQUEST,
- 'Library does not allow method ' .
- "$method for 'gopher:' URLs");
- }
-
- my $gophertype = $url->gopher_type;
- unless (exists $gopher2mimetype{$gophertype}) {
- return HTTP::Response->new(HTTP::Status::RC_NOT_IMPLEMENTED,
- 'Library does not support gophertype ' .
- $gophertype);
- }
-
- my $response = HTTP::Response->new(HTTP::Status::RC_OK, "OK");
- $response->header('Content-type' => $gopher2mimetype{$gophertype}
- || 'text/plain');
- $response->header('Content-Encoding' => $gopher2encoding{$gophertype})
- if exists $gopher2encoding{$gophertype};
-
- if ($method eq 'HEAD') {
- # XXX: don't even try it so we set this header
- $response->header('Client-Warning' => 'Client answer only');
- return $response;
- }
-
- if ($gophertype eq '7' && ! $url->search) {
- # the url is the prompt for a gopher search; supply boiler-plate
- return $self->collect_once($arg, $response, <<"EOT");
-<HEAD>
-<TITLE>Gopher Index</TITLE>
-<ISINDEX>
-</HEAD>
-<BODY>
-<H1>$url<BR>Gopher Search</H1>
-This is a searchable Gopher index.
-Use the search function of your browser to enter search terms.
-</BODY>
-EOT
- }
-
- my $host = $url->host;
- my $port = $url->port;
-
- my $requestLine = "";
-
- my $selector = $url->selector;
- if (defined $selector) {
- $requestLine .= $selector;
- my $search = $url->search;
- if (defined $search) {
- $requestLine .= "\t$search";
- my $string = $url->string;
- if (defined $string) {
- $requestLine .= "\t$string";
- }
- }
- }
- $requestLine .= "\015\012";
-
- # potential request headers are just ignored
-
- # Ok, lets make the request
- my $socket = IO::Socket::INET->new(PeerAddr => $host,
- PeerPort => $port,
- LocalAddr => $self->{ua}{local_address},
- Proto => 'tcp',
- Timeout => $timeout);
- die "Can't connect to $host:$port" unless $socket;
- my $sel = IO::Select->new($socket);
-
- {
- die "write timeout" if $timeout && !$sel->can_write($timeout);
- my $n = syswrite($socket, $requestLine, length($requestLine));
- die $! unless defined($n);
- die "short write" if $n != length($requestLine);
- }
-
- my $user_arg = $arg;
-
- # must handle menus in a special way since they are to be
- # converted to HTML. Undefing $arg ensures that the user does
- # not see the data before we get a change to convert it.
- $arg = undef if $gophertype eq '1' || $gophertype eq '7';
-
- # collect response
- my $buf = '';
- $response = $self->collect($arg, $response, sub {
- die "read timeout" if $timeout && !$sel->can_read($timeout);
- my $n = sysread($socket, $buf, $size);
- die $! unless defined($n);
- return \$buf;
- } );
-
- # Convert menu to HTML and return data to user.
- if ($gophertype eq '1' || $gophertype eq '7') {
- my $content = menu2html($response->content);
- if (defined $user_arg) {
- $response = $self->collect_once($user_arg, $response, $content);
- }
- else {
- $response->content($content);
- }
- }
-
- $response;
-}
-
-
-sub gopher2url
-{
- my($gophertype, $path, $host, $port) = @_;
-
- my $url;
-
- if ($gophertype eq '8' || $gophertype eq 'T') {
- # telnet session
- $url = $HTTP::URI_CLASS->new($gophertype eq '8' ? 'telnet:':'tn3270:');
- $url->user($path) if defined $path;
- }
- else {
- $path = URI::Escape::uri_escape($path);
- $url = $HTTP::URI_CLASS->new("gopher:/$gophertype$path");
- }
- $url->host($host);
- $url->port($port);
- $url;
-}
-
-sub menu2html {
- my($menu) = @_;
-
- $menu =~ tr/\015//d; # remove carriage return
- my $tmp = <<"EOT";
-<HTML>
-<HEAD>
- <TITLE>Gopher menu</TITLE>
-</HEAD>
-<BODY>
-<H1>Gopher menu</H1>
-EOT
- for (split("\n", $menu)) {
- last if /^\./;
- my($pretty, $path, $host, $port) = split("\t");
-
- $pretty =~ s/^(.)//;
- my $type = $1;
-
- my $url = gopher2url($type, $path, $host, $port)->as_string;
- $tmp .= qq{<A HREF="$url">$pretty</A><BR>\n};
- }
- $tmp .= "</BODY>\n</HTML>\n";
- $tmp;
-}
-
-1;
diff --git a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/http.pm b/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/http.pm
deleted file mode 100644
index 88b4c60df3..0000000000
--- a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/http.pm
+++ /dev/null
@@ -1,523 +0,0 @@
-package LWP::Protocol::http;
-
-use strict;
-
-our $VERSION = '6.61';
-
-require HTTP::Response;
-require HTTP::Status;
-require Net::HTTP;
-
-use parent qw(LWP::Protocol);
-
-our @EXTRA_SOCK_OPTS;
-my $CRLF = "\015\012";
-
-sub _new_socket
-{
- my($self, $host, $port, $timeout) = @_;
-
- # IPv6 literal IP address should be [bracketed] to remove
- # ambiguity between ip address and port number.
- if ( ($host =~ /:/) && ($host !~ /^\[/) ) {
- $host = "[$host]";
- }
-
- local($^W) = 0; # IO::Socket::INET can be noisy
- my $sock = $self->socket_class->new(PeerAddr => $host,
- PeerPort => $port,
- LocalAddr => $self->{ua}{local_address},
- Proto => 'tcp',
- Timeout => $timeout,
- KeepAlive => !!$self->{ua}{conn_cache},
- SendTE => $self->{ua}{send_te},
- $self->_extra_sock_opts($host, $port),
- );
-
- unless ($sock) {
- # IO::Socket::INET leaves additional error messages in $@
- my $status = "Can't connect to $host:$port";
- if ($@ =~ /\bconnect: (.*)/ ||
- $@ =~ /\b(Bad hostname)\b/ ||
- $@ =~ /\b(nodename nor servname provided, or not known)\b/ ||
- $@ =~ /\b(certificate verify failed)\b/ ||
- $@ =~ /\b(Crypt-SSLeay can't verify hostnames)\b/
- ) {
- $status .= " ($1)";
- } elsif ($@) {
- $status .= " ($@)";
- }
- die "$status\n\n$@";
- }
-
- # perl 5.005's IO::Socket does not have the blocking method.
- eval { $sock->blocking(0); };
-
- $sock;
-}
-
-sub socket_type
-{
- return "http";
-}
-
-sub socket_class
-{
- my $self = shift;
- (ref($self) || $self) . "::Socket";
-}
-
-sub _extra_sock_opts # to be overridden by subclass
-{
- return @EXTRA_SOCK_OPTS;
-}
-
-sub _check_sock
-{
- #my($self, $req, $sock) = @_;
-}
-
-sub _get_sock_info
-{
- my($self, $res, $sock) = @_;
- if (defined(my $peerhost = $sock->peerhost)) {
- $res->header("Client-Peer" => "$peerhost:" . $sock->peerport);
- }
-}
-
-sub _fixup_header
-{
- my($self, $h, $url, $proxy) = @_;
-
- # Extract 'Host' header
- my $hhost = $url->authority;
- if ($hhost =~ s/^([^\@]*)\@//) { # get rid of potential "user:pass@"
- # add authorization header if we need them. HTTP URLs do
- # not really support specification of user and password, but
- # we allow it.
- if (defined($1) && not $h->header('Authorization')) {
- require URI::Escape;
- $h->authorization_basic(map URI::Escape::uri_unescape($_),
- split(":", $1, 2));
- }
- }
- $h->init_header('Host' => $hhost);
-
- if ($proxy && $url->scheme ne 'https') {
- # Check the proxy URI's userinfo() for proxy credentials
- # export http_proxy="http://proxyuser:proxypass@proxyhost:port".
- # For https only the initial CONNECT requests needs authorization.
- my $p_auth = $proxy->userinfo();
- if(defined $p_auth) {
- require URI::Escape;
- $h->proxy_authorization_basic(map URI::Escape::uri_unescape($_),
- split(":", $p_auth, 2))
- }
- }
-}
-
-sub hlist_remove {
- my($hlist, $k) = @_;
- $k = lc $k;
- for (my $i = @$hlist - 2; $i >= 0; $i -= 2) {
- next unless lc($hlist->[$i]) eq $k;
- splice(@$hlist, $i, 2);
- }
-}
-
-sub request
-{
- my($self, $request, $proxy, $arg, $size, $timeout) = @_;
-
- $size ||= 4096;
-
- # check method
- my $method = $request->method;
- unless ($method =~ /^[A-Za-z0-9_!\#\$%&\'*+\-.^\`|~]+$/) { # HTTP token
- return HTTP::Response->new( HTTP::Status::RC_BAD_REQUEST,
- 'Library does not allow method ' .
- "$method for 'http:' URLs");
- }
-
- my $url = $request->uri;
-
- # Proxying SSL with a http proxy needs issues a CONNECT request to build a
- # tunnel and then upgrades the tunnel to SSL. But when doing keep-alive the
- # https request does not need to be the first request in the connection, so
- # we need to distinguish between
- # - not yet connected (create socket and ssl upgrade)
- # - connected but not inside ssl tunnel (ssl upgrade)
- # - inside ssl tunnel to the target - once we are in the tunnel to the
- # target we cannot only reuse the tunnel for more https requests with the
- # same target
-
- my $ssl_tunnel = $proxy && $url->scheme eq 'https'
- && $url->host.":".$url->port;
-
- my ($host,$port) = $proxy
- ? ($proxy->host,$proxy->port)
- : ($url->host,$url->port);
- my $fullpath =
- $method eq 'CONNECT' ? $url->host . ":" . $url->port :
- $proxy && ! $ssl_tunnel ? $url->as_string :
- do {
- my $path = $url->path_query;
- $path = "/$path" if $path !~m{^/};
- $path
- };
-
- my $socket;
- my $conn_cache = $self->{ua}{conn_cache};
- my $cache_key;
- if ( $conn_cache ) {
- $cache_key = "$host:$port";
- # For https we reuse the socket immediately only if it has an established
- # tunnel to the target. Otherwise a CONNECT request followed by an SSL
- # upgrade need to be done first. The request itself might reuse an
- # existing non-ssl connection to the proxy
- $cache_key .= "!".$ssl_tunnel if $ssl_tunnel;
- if ( $socket = $conn_cache->withdraw($self->socket_type,$cache_key)) {
- if ($socket->can_read(0)) {
- # if the socket is readable, then either the peer has closed the
- # connection or there are some garbage bytes on it. In either
- # case we abandon it.
- $socket->close;
- $socket = undef;
- } # else use $socket
- else {
- $socket->timeout($timeout);
- }
- }
- }
-
- if ( ! $socket && $ssl_tunnel ) {
- my $proto_https = LWP::Protocol::create('https',$self->{ua})
- or die "no support for scheme https found";
-
- # only if ssl socket class is IO::Socket::SSL we can upgrade
- # a plain socket to SSL. In case of Net::SSL we fall back to
- # the old version
- if ( my $upgrade_sub = $proto_https->can('_upgrade_sock')) {
- my $response = $self->request(
- HTTP::Request->new('CONNECT',"http://$ssl_tunnel"),
- $proxy,
- undef,$size,$timeout
- );
- $response->is_success or die
- "establishing SSL tunnel failed: ".$response->status_line;
- $socket = $upgrade_sub->($proto_https,
- $response->{client_socket},$url)
- or die "SSL upgrade failed: $@";
- } else {
- $socket = $proto_https->_new_socket($url->host,$url->port,$timeout);
- }
- }
-
- if ( ! $socket ) {
- # connect to remote site w/o reusing established socket
- $socket = $self->_new_socket($host, $port, $timeout );
- }
-
- my $http_version = "";
- if (my $proto = $request->protocol) {
- if ($proto =~ /^(?:HTTP\/)?(1.\d+)$/) {
- $http_version = $1;
- $socket->http_version($http_version);
- $socket->send_te(0) if $http_version eq "1.0";
- }
- }
-
- $self->_check_sock($request, $socket);
-
- my @h;
- my $request_headers = $request->headers->clone;
- $self->_fixup_header($request_headers, $url, $proxy);
-
- $request_headers->scan(sub {
- my($k, $v) = @_;
- $k =~ s/^://;
- $v =~ tr/\n/ /;
- push(@h, $k, $v);
- });
-
- my $content_ref = $request->content_ref;
- $content_ref = $$content_ref if ref($$content_ref);
- my $chunked;
- my $has_content;
-
- if (ref($content_ref) eq 'CODE') {
- my $clen = $request_headers->header('Content-Length');
- $has_content++ if $clen;
- unless (defined $clen) {
- push(@h, "Transfer-Encoding" => "chunked");
- $has_content++;
- $chunked++;
- }
- }
- else {
- # Set (or override) Content-Length header
- my $clen = $request_headers->header('Content-Length');
- if (defined($$content_ref) && length($$content_ref)) {
- $has_content = length($$content_ref);
- if (!defined($clen) || $clen ne $has_content) {
- if (defined $clen) {
- warn "Content-Length header value was wrong, fixed";
- hlist_remove(\@h, 'Content-Length');
- }
- push(@h, 'Content-Length' => $has_content);
- }
- }
- elsif ($clen) {
- warn "Content-Length set when there is no content, fixed";
- hlist_remove(\@h, 'Content-Length');
- }
- }
-
- my $write_wait = 0;
- $write_wait = 2
- if ($request_headers->header("Expect") || "") =~ /100-continue/;
-
- my $req_buf = $socket->format_request($method, $fullpath, @h);
- #print "------\n$req_buf\n------\n";
-
- if (!$has_content || $write_wait || $has_content > 8*1024) {
- WRITE:
- {
- # Since this just writes out the header block it should almost
- # always succeed to send the whole buffer in a single write call.
- my $n = $socket->syswrite($req_buf, length($req_buf));
- unless (defined $n) {
- redo WRITE if $!{EINTR};
- if ($!{EWOULDBLOCK} || $!{EAGAIN}) {
- select(undef, undef, undef, 0.1);
- redo WRITE;
- }
- die "write failed: $!";
- }
- if ($n) {
- substr($req_buf, 0, $n, "");
- }
- else {
- select(undef, undef, undef, 0.5);
- }
- redo WRITE if length $req_buf;
- }
- }
-
- my($code, $mess, @junk);
- my $drop_connection;
-
- if ($has_content) {
- my $eof;
- my $wbuf;
- my $woffset = 0;
- INITIAL_READ:
- if ($write_wait) {
- # skip filling $wbuf when waiting for 100-continue
- # because if the response is a redirect or auth required
- # the request will be cloned and there is no way
- # to reset the input stream
- # return here via the label after the 100-continue is read
- }
- elsif (ref($content_ref) eq 'CODE') {
- my $buf = &$content_ref();
- $buf = "" unless defined($buf);
- $buf = sprintf "%x%s%s%s", length($buf), $CRLF, $buf, $CRLF
- if $chunked;
- substr($buf, 0, 0) = $req_buf if $req_buf;
- $wbuf = \$buf;
- }
- else {
- if ($req_buf) {
- my $buf = $req_buf . $$content_ref;
- $wbuf = \$buf;
- }
- else {
- $wbuf = $content_ref;
- }
- $eof = 1;
- }
-
- my $fbits = '';
- vec($fbits, fileno($socket), 1) = 1;
-
- WRITE:
- while ($write_wait || $woffset < length($$wbuf)) {
-
- my $sel_timeout = $timeout;
- if ($write_wait) {
- $sel_timeout = $write_wait if $write_wait < $sel_timeout;
- }
- my $time_before;
- $time_before = time if $sel_timeout;
-
- my $rbits = $fbits;
- my $wbits = $write_wait ? undef : $fbits;
- my $sel_timeout_before = $sel_timeout;
- SELECT:
- {
- my $nfound = select($rbits, $wbits, undef, $sel_timeout);
- if ($nfound < 0) {
- if ($!{EINTR} || $!{EWOULDBLOCK} || $!{EAGAIN}) {
- if ($time_before) {
- $sel_timeout = $sel_timeout_before - (time - $time_before);
- $sel_timeout = 0 if $sel_timeout < 0;
- }
- redo SELECT;
- }
- die "select failed: $!";
- }
- }
-
- if ($write_wait) {
- $write_wait -= time - $time_before;
- $write_wait = 0 if $write_wait < 0;
- }
-
- if (defined($rbits) && $rbits =~ /[^\0]/) {
- # readable
- my $buf = $socket->_rbuf;
- my $n = $socket->sysread($buf, 1024, length($buf));
- unless (defined $n) {
- die "read failed: $!" unless $!{EINTR} || $!{EWOULDBLOCK} || $!{EAGAIN};
- # if we get here the rest of the block will do nothing
- # and we will retry the read on the next round
- }
- elsif ($n == 0) {
- # the server closed the connection before we finished
- # writing all the request content. No need to write any more.
- $drop_connection++;
- last WRITE;
- }
- $socket->_rbuf($buf);
- if (!$code && $buf =~ /\015?\012\015?\012/) {
- # a whole response header is present, so we can read it without blocking
- ($code, $mess, @h) = $socket->read_response_headers(laxed => 1,
- junk_out => \@junk,
- );
- if ($code eq "100") {
- $write_wait = 0;
- undef($code);
- goto INITIAL_READ;
- }
- else {
- $drop_connection++;
- last WRITE;
- # XXX should perhaps try to abort write in a nice way too
- }
- }
- }
- if (defined($wbits) && $wbits =~ /[^\0]/) {
- my $n = $socket->syswrite($$wbuf, length($$wbuf), $woffset);
- unless (defined $n) {
- die "write failed: $!" unless $!{EINTR} || $!{EWOULDBLOCK} || $!{EAGAIN};
- $n = 0; # will retry write on the next round
- }
- elsif ($n == 0) {
- die "write failed: no bytes written";
- }
- $woffset += $n;
-
- if (!$eof && $woffset >= length($$wbuf)) {
- # need to refill buffer from $content_ref code
- my $buf = &$content_ref();
- $buf = "" unless defined($buf);
- $eof++ unless length($buf);
- $buf = sprintf "%x%s%s%s", length($buf), $CRLF, $buf, $CRLF
- if $chunked;
- $wbuf = \$buf;
- $woffset = 0;
- }
- }
- } # WRITE
- }
-
- ($code, $mess, @h) = $socket->read_response_headers(laxed => 1, junk_out => \@junk)
- unless $code;
- ($code, $mess, @h) = $socket->read_response_headers(laxed => 1, junk_out => \@junk)
- if $code eq "100";
-
- my $response = HTTP::Response->new($code, $mess);
- my $peer_http_version = $socket->peer_http_version;
- $response->protocol("HTTP/$peer_http_version");
- {
- local $HTTP::Headers::TRANSLATE_UNDERSCORE;
- $response->push_header(@h);
- }
- $response->push_header("Client-Junk" => \@junk) if @junk;
-
- $response->request($request);
- $self->_get_sock_info($response, $socket);
-
- if ($method eq "CONNECT") {
- $response->{client_socket} = $socket; # so it can be picked up
- return $response;
- }
-
- if (my @te = $response->remove_header('Transfer-Encoding')) {
- $response->push_header('Client-Transfer-Encoding', \@te);
- }
- $response->push_header('Client-Response-Num', scalar $socket->increment_response_count);
-
- my $complete;
- $response = $self->collect($arg, $response, sub {
- my $buf = ""; #prevent use of uninitialized value in SSLeay.xs
- my $n;
- READ:
- {
- $n = $socket->read_entity_body($buf, $size);
- unless (defined $n) {
- redo READ if $!{EINTR} || $!{EWOULDBLOCK} || $!{EAGAIN} || $!{ENOTTY};
- die "read failed: $!";
- }
- redo READ if $n == -1;
- }
- $complete++ if !$n;
- return \$buf;
- } );
- $drop_connection++ unless $complete;
-
- @h = $socket->get_trailers;
- if (@h) {
- local $HTTP::Headers::TRANSLATE_UNDERSCORE;
- $response->push_header(@h);
- }
-
- # keep-alive support
- unless ($drop_connection) {
- if ($cache_key) {
- my %connection = map { (lc($_) => 1) }
- split(/\s*,\s*/, ($response->header("Connection") || ""));
- if (($peer_http_version eq "1.1" && !$connection{close}) ||
- $connection{"keep-alive"})
- {
- $conn_cache->deposit($self->socket_type, $cache_key, $socket);
- }
- }
- }
-
- $response;
-}
-
-
-#-----------------------------------------------------------
-package # hide from PAUSE
- LWP::Protocol::http::SocketMethods;
-
-sub ping {
- my $self = shift;
- !$self->can_read(0);
-}
-
-sub increment_response_count {
- my $self = shift;
- return ++${*$self}{'myhttp_response_count'};
-}
-
-#-----------------------------------------------------------
-package # hide from PAUSE
- LWP::Protocol::http::Socket;
-
-use parent -norequire, qw(LWP::Protocol::http::SocketMethods Net::HTTP);
-
-1;
diff --git a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/loopback.pm b/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/loopback.pm
deleted file mode 100644
index a1b095ea70..0000000000
--- a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/loopback.pm
+++ /dev/null
@@ -1,27 +0,0 @@
-package LWP::Protocol::loopback;
-
-use strict;
-
-our $VERSION = '6.61';
-
-require HTTP::Response;
-
-use parent qw(LWP::Protocol);
-
-sub request {
- my($self, $request, $proxy, $arg, $size, $timeout) = @_;
-
- my $response = HTTP::Response->new(200, "OK");
- $response->content_type("message/http; msgtype=request");
-
- $response->header("Via", "loopback/1.0 $proxy")
- if $proxy;
-
- $response->header("X-Arg", $arg);
- $response->header("X-Read-Size", $size);
- $response->header("X-Timeout", $timeout);
-
- return $self->collect_once($arg, $response, $request->as_string);
-}
-
-1;
diff --git a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/mailto.pm b/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/mailto.pm
deleted file mode 100644
index 29f934bb26..0000000000
--- a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/mailto.pm
+++ /dev/null
@@ -1,184 +0,0 @@
-package LWP::Protocol::mailto;
-
-# This module implements the mailto protocol. It is just a simple
-# frontend to the Unix sendmail program except on MacOS, where it uses
-# Mail::Internet.
-
-require HTTP::Request;
-require HTTP::Response;
-require HTTP::Status;
-
-use Carp;
-use strict;
-
-our $VERSION = '6.61';
-
-use parent qw(LWP::Protocol);
-our $SENDMAIL;
-
-unless ($SENDMAIL = $ENV{SENDMAIL}) {
- for my $sm (qw(/usr/sbin/sendmail
- /usr/lib/sendmail
- /usr/ucblib/sendmail
- ))
- {
- if (-x $sm) {
- $SENDMAIL = $sm;
- last;
- }
- }
- die "Can't find the 'sendmail' program" unless $SENDMAIL;
-}
-
-sub request
-{
- my($self, $request, $proxy, $arg, $size) = @_;
-
- my ($mail, $addr) if $^O eq "MacOS";
- my @text = () if $^O eq "MacOS";
-
- # check proxy
- if (defined $proxy)
- {
- return HTTP::Response->new(HTTP::Status::RC_BAD_REQUEST,
- 'You can not proxy with mail');
- }
-
- # check method
- my $method = $request->method;
-
- if ($method ne 'POST') {
- return HTTP::Response->new( HTTP::Status::RC_BAD_REQUEST,
- 'Library does not allow method ' .
- "$method for 'mailto:' URLs");
- }
-
- # check url
- my $url = $request->uri;
-
- my $scheme = $url->scheme;
- if ($scheme ne 'mailto') {
- return HTTP::Response->new( HTTP::Status::RC_INTERNAL_SERVER_ERROR,
- "LWP::Protocol::mailto::request called for '$scheme'");
- }
- if ($^O eq "MacOS") {
- eval {
- require Mail::Internet;
- };
- if($@) {
- return HTTP::Response->new( HTTP::Status::RC_INTERNAL_SERVER_ERROR,
- "You don't have MailTools installed");
- }
- unless ($ENV{SMTPHOSTS}) {
- return HTTP::Response->new( HTTP::Status::RC_INTERNAL_SERVER_ERROR,
- "You don't have SMTPHOSTS defined");
- }
- }
- else {
- unless (-x $SENDMAIL) {
- return HTTP::Response->new( HTTP::Status::RC_INTERNAL_SERVER_ERROR,
- "You don't have $SENDMAIL");
- }
- }
- if ($^O eq "MacOS") {
- $mail = Mail::Internet->new or
- return HTTP::Response->new( HTTP::Status::RC_INTERNAL_SERVER_ERROR,
- "Can't get a Mail::Internet object");
- }
- else {
- open(SENDMAIL, "| $SENDMAIL -oi -t") or
- return HTTP::Response->new( HTTP::Status::RC_INTERNAL_SERVER_ERROR,
- "Can't run $SENDMAIL: $!");
- }
- if ($^O eq "MacOS") {
- $addr = $url->encoded822addr;
- }
- else {
- $request = $request->clone; # we modify a copy
- my @h = $url->headers; # URL headers override those in the request
- while (@h) {
- my $k = shift @h;
- my $v = shift @h;
- next unless defined $v;
- if (lc($k) eq "body") {
- $request->content($v);
- }
- else {
- $request->push_header($k => $v);
- }
- }
- }
- if ($^O eq "MacOS") {
- $mail->add(To => $addr);
- $mail->add(split(/[:\n]/,$request->headers_as_string));
- }
- else {
- print SENDMAIL $request->headers_as_string;
- print SENDMAIL "\n";
- }
- my $content = $request->content;
- if (defined $content) {
- my $contRef = ref($content) ? $content : \$content;
- if (ref($contRef) eq 'SCALAR') {
- if ($^O eq "MacOS") {
- @text = split("\n",$$contRef);
- foreach (@text) {
- $_ .= "\n";
- }
- }
- else {
- print SENDMAIL $$contRef;
- }
-
- }
- elsif (ref($contRef) eq 'CODE') {
- # Callback provides data
- my $d;
- if ($^O eq "MacOS") {
- my $stuff = "";
- while (length($d = &$contRef)) {
- $stuff .= $d;
- }
- @text = split("\n",$stuff);
- foreach (@text) {
- $_ .= "\n";
- }
- }
- else {
- print SENDMAIL $d;
- }
- }
- }
- if ($^O eq "MacOS") {
- $mail->body(\@text);
- unless ($mail->smtpsend) {
- return HTTP::Response->new(HTTP::Status::RC_INTERNAL_SERVER_ERROR,
- "Mail::Internet->smtpsend unable to send message to <$addr>");
- }
- }
- else {
- unless (close(SENDMAIL)) {
- my $err = $! ? "$!" : "Exit status $?";
- return HTTP::Response->new(HTTP::Status::RC_INTERNAL_SERVER_ERROR,
- "$SENDMAIL: $err");
- }
- }
-
-
- my $response = HTTP::Response->new(HTTP::Status::RC_ACCEPTED,
- "Mail accepted");
- $response->header('Content-Type', 'text/plain');
- if ($^O eq "MacOS") {
- $response->header('Server' => "Mail::Internet $Mail::Internet::VERSION");
- $response->content("Message sent to <$addr>\n");
- }
- else {
- $response->header('Server' => $SENDMAIL);
- my $to = $request->header("To");
- $response->content("Message sent to <$to>\n");
- }
-
- return $response;
-}
-
-1;
diff --git a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/nntp.pm b/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/nntp.pm
deleted file mode 100644
index 1042cd40c3..0000000000
--- a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/nntp.pm
+++ /dev/null
@@ -1,150 +0,0 @@
-package LWP::Protocol::nntp;
-
-# Implementation of the Network News Transfer Protocol (RFC 977)
-
-use parent qw(LWP::Protocol);
-
-our $VERSION = '6.61';
-
-require HTTP::Response;
-require HTTP::Status;
-require Net::NNTP;
-
-use strict;
-
-
-sub request {
- my ($self, $request, $proxy, $arg, $size, $timeout) = @_;
-
- $size = 4096 unless $size;
-
- # Check for proxy
- if (defined $proxy) {
- return HTTP::Response->new(HTTP::Status::RC_BAD_REQUEST,
- 'You can not proxy through NNTP');
- }
-
- # Check that the scheme is as expected
- my $url = $request->uri;
- my $scheme = $url->scheme;
- unless ($scheme eq 'news' || $scheme eq 'nntp') {
- return HTTP::Response->new(HTTP::Status::RC_INTERNAL_SERVER_ERROR,
- "LWP::Protocol::nntp::request called for '$scheme'");
- }
-
- # check for a valid method
- my $method = $request->method;
- unless ($method eq 'GET' || $method eq 'HEAD' || $method eq 'POST') {
- return HTTP::Response->new(HTTP::Status::RC_BAD_REQUEST,
- 'Library does not allow method ' . "$method for '$scheme:' URLs");
- }
-
- # extract the identifier and check against posting to an article
- my $groupart = $url->_group;
- my $is_art = $groupart =~ /@/;
-
- if ($is_art && $method eq 'POST') {
- return HTTP::Response->new(HTTP::Status::RC_BAD_REQUEST,
- "Can't post to an article <$groupart>");
- }
-
- my $nntp = Net::NNTP->new(
- $url->host,
-
- #Port => 18574,
- Timeout => $timeout,
-
- #Debug => 1,
- );
- die "Can't connect to nntp server" unless $nntp;
-
- # Check the initial welcome message from the NNTP server
- if ($nntp->status != 2) {
- return HTTP::Response->new(HTTP::Status::RC_SERVICE_UNAVAILABLE,
- $nntp->message);
- }
- my $response = HTTP::Response->new(HTTP::Status::RC_OK, "OK");
-
- my $mess = $nntp->message;
-
- # Try to extract server name from greeting message.
- # Don't know if this works well for a large class of servers, but
- # this works for our server.
- $mess =~ s/\s+ready\b.*//;
- $mess =~ s/^\S+\s+//;
- $response->header(Server => $mess);
-
- # First we handle posting of articles
- if ($method eq 'POST') {
- $nntp->quit;
- $nntp = undef;
- $response->code(HTTP::Status::RC_NOT_IMPLEMENTED);
- $response->message("POST not implemented yet");
- return $response;
- }
-
- # The method must be "GET" or "HEAD" by now
- if (!$is_art) {
- if (!$nntp->group($groupart)) {
- $response->code(HTTP::Status::RC_NOT_FOUND);
- $response->message($nntp->message);
- }
- $nntp->quit;
- $nntp = undef;
-
- # HEAD: just check if the group exists
- if ($method eq 'GET' && $response->is_success) {
- $response->code(HTTP::Status::RC_NOT_IMPLEMENTED);
- $response->message("GET newsgroup not implemented yet");
- }
- return $response;
- }
-
- # Send command to server to retrieve an article (or just the headers)
- my $get = $method eq 'HEAD' ? "head" : "article";
- my $art = $nntp->$get("<$groupart>");
- unless ($art) {
- $nntp->quit;
- $response->code(HTTP::Status::RC_NOT_FOUND);
- $response->message($nntp->message);
- $nntp = undef;
- return $response;
- }
-
- # Parse headers
- my ($key, $val);
- local $_;
- while ($_ = shift @$art) {
- if (/^\s+$/) {
- last; # end of headers
- }
- elsif (/^(\S+):\s*(.*)/) {
- $response->push_header($key, $val) if $key;
- ($key, $val) = ($1, $2);
- }
- elsif (/^\s+(.*)/) {
- next unless $key;
- $val .= $1;
- }
- else {
- unshift(@$art, $_);
- last;
- }
- }
- $response->push_header($key, $val) if $key;
-
- # Ensure that there is a Content-Type header
- $response->header("Content-Type", "text/plain")
- unless $response->header("Content-Type");
-
- # Collect the body
- $response = $self->collect_once($arg, $response, join("", @$art)) if @$art;
-
- # Say goodbye to the server
- $nntp->quit;
- $nntp = undef;
-
- $response;
-}
-
-1;
diff --git a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/nogo.pm b/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/nogo.pm
deleted file mode 100644
index dcc54cfc7d..0000000000
--- a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Protocol/nogo.pm
+++ /dev/null
@@ -1,25 +0,0 @@
-package LWP::Protocol::nogo;
-# If you want to disable access to a particular scheme, use this
-# class and then call
-# LWP::Protocol::implementor(that_scheme, 'LWP::Protocol::nogo');
-# For then on, attempts to access URLs with that scheme will generate
-# a 500 error.
-
-use strict;
-
-our $VERSION = '6.61';
-
-require HTTP::Response;
-require HTTP::Status;
-use parent qw(LWP::Protocol);
-
-sub request {
- my($self, $request) = @_;
- my $scheme = $request->uri->scheme;
-
- return HTTP::Response->new(
- HTTP::Status::RC_INTERNAL_SERVER_ERROR,
- "Access to \'$scheme\' URIs has been disabled"
- );
-}
-1;
diff --git a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/RobotUA.pm b/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/RobotUA.pm
deleted file mode 100644
index 028bdef7af..0000000000
--- a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/RobotUA.pm
+++ /dev/null
@@ -1,312 +0,0 @@
-package LWP::RobotUA;
-
-use parent qw(LWP::UserAgent);
-
-our $VERSION = '6.61';
-
-require WWW::RobotRules;
-require HTTP::Request;
-require HTTP::Response;
-
-use Carp ();
-use HTTP::Status ();
-use HTTP::Date qw(time2str);
-use strict;
-
-
-#
-# Additional attributes in addition to those found in LWP::UserAgent:
-#
-# $self->{'delay'} Required delay between request to the same
-# server in minutes.
-#
-# $self->{'rules'} A WWW::RobotRules object
-#
-
-sub new
-{
- my $class = shift;
- my %cnf;
- if (@_ < 4) {
- # legacy args
- @cnf{qw(agent from rules)} = @_;
- }
- else {
- %cnf = @_;
- }
-
- Carp::croak('LWP::RobotUA agent required') unless $cnf{agent};
- Carp::croak('LWP::RobotUA from address required')
- unless $cnf{from} && $cnf{from} =~ m/\@/;
-
- my $delay = delete $cnf{delay} || 1;
- my $use_sleep = delete $cnf{use_sleep};
- $use_sleep = 1 unless defined($use_sleep);
- my $rules = delete $cnf{rules};
-
- my $self = LWP::UserAgent->new(%cnf);
- $self = bless $self, $class;
-
- $self->{'delay'} = $delay; # minutes
- $self->{'use_sleep'} = $use_sleep;
-
- if ($rules) {
- $rules->agent($cnf{agent});
- $self->{'rules'} = $rules;
- }
- else {
- $self->{'rules'} = WWW::RobotRules->new($cnf{agent});
- }
-
- $self;
-}
-
-
-sub delay { shift->_elem('delay', @_); }
-sub use_sleep { shift->_elem('use_sleep', @_); }
-
-
-sub agent
-{
- my $self = shift;
- my $old = $self->SUPER::agent(@_);
- if (@_) {
- # Changing our name means to start fresh
- $self->{'rules'}->agent($self->{'agent'});
- }
- $old;
-}
-
-
-sub rules {
- my $self = shift;
- my $old = $self->_elem('rules', @_);
- $self->{'rules'}->agent($self->{'agent'}) if @_;
- $old;
-}
-
-
-sub no_visits
-{
- my($self, $netloc) = @_;
- $self->{'rules'}->no_visits($netloc) || 0;
-}
-
-*host_count = \&no_visits; # backwards compatibility with LWP-5.02
-
-
-sub host_wait
-{
- my($self, $netloc) = @_;
- return undef unless defined $netloc;
- my $last = $self->{'rules'}->last_visit($netloc);
- if ($last) {
- my $wait = int($self->{'delay'} * 60 - (time - $last));
- $wait = 0 if $wait < 0;
- return $wait;
- }
- return 0;
-}
-
-
-sub simple_request
-{
- my($self, $request, $arg, $size) = @_;
-
- # Do we try to access a new server?
- my $allowed = $self->{'rules'}->allowed($request->uri);
-
- if ($allowed < 0) {
- # Host is not visited before, or robots.txt expired; fetch "robots.txt"
- my $robot_url = $request->uri->clone;
- $robot_url->path("robots.txt");
- $robot_url->query(undef);
-
- # make access to robot.txt legal since this will be a recursive call
- $self->{'rules'}->parse($robot_url, "");
-
- my $robot_req = HTTP::Request->new('GET', $robot_url);
- my $parse_head = $self->parse_head(0);
- my $robot_res = $self->request($robot_req);
- $self->parse_head($parse_head);
- my $fresh_until = $robot_res->fresh_until;
- my $content = "";
- if ($robot_res->is_success && $robot_res->content_is_text) {
- $content = $robot_res->decoded_content;
- $content = "" unless $content && $content =~ /^\s*Disallow\s*:/mi;
- }
- $self->{'rules'}->parse($robot_url, $content, $fresh_until);
-
- # recalculate allowed...
- $allowed = $self->{'rules'}->allowed($request->uri);
- }
-
- # Check rules
- unless ($allowed) {
- my $res = HTTP::Response->new(
- HTTP::Status::RC_FORBIDDEN, 'Forbidden by robots.txt');
- $res->request( $request ); # bind it to that request
- return $res;
- }
-
- my $netloc = eval { local $SIG{__DIE__}; $request->uri->host_port; };
- my $wait = $self->host_wait($netloc);
-
- if ($wait) {
- if ($self->{'use_sleep'}) {
- sleep($wait)
- }
- else {
- my $res = HTTP::Response->new(
- HTTP::Status::RC_SERVICE_UNAVAILABLE, 'Please, slow down');
- $res->header('Retry-After', time2str(time + $wait));
- $res->request( $request ); # bind it to that request
- return $res;
- }
- }
-
- # Perform the request
- my $res = $self->SUPER::simple_request($request, $arg, $size);
-
- $self->{'rules'}->visit($netloc);
-
- $res;
-}
-
-
-sub as_string
-{
- my $self = shift;
- my @s;
- push(@s, "Robot: $self->{'agent'} operated by $self->{'from'} [$self]");
- push(@s, " Minimum delay: " . int($self->{'delay'}*60) . "s");
- push(@s, " Will sleep if too early") if $self->{'use_sleep'};
- push(@s, " Rules = $self->{'rules'}");
- join("\n", @s, '');
-}
-
-1;
-
-
-__END__
-
-=pod
-
-=head1 NAME
-
-LWP::RobotUA - a class for well-behaved Web robots
-
-=head1 SYNOPSIS
-
- use LWP::RobotUA;
- my $ua = LWP::RobotUA->new('my-robot/0.1', 'me@foo.com');
- $ua->delay(10); # be very nice -- max one hit every ten minutes!
- ...
-
- # Then just use it just like a normal LWP::UserAgent:
- my $response = $ua->get('http://whatever.int/...');
- ...
-
-=head1 DESCRIPTION
-
-This class implements a user agent that is suitable for robot
-applications. Robots should be nice to the servers they visit. They
-should consult the F</robots.txt> file to ensure that they are welcomed
-and they should not make requests too frequently.
-
-But before you consider writing a robot, take a look at
-L<http://www.robotstxt.org/>.
-
-When you use an I<LWP::RobotUA> object as your user agent, then you do not
-really have to think about these things yourself; C<robots.txt> files
-are automatically consulted and obeyed, the server isn't queried
-too rapidly, and so on. Just send requests
-as you do when you are using a normal I<LWP::UserAgent>
-object (using C<< $ua->get(...) >>, C<< $ua->head(...) >>,
-C<< $ua->request(...) >>, etc.), and this
-special agent will make sure you are nice.
-
-=head1 METHODS
-
-The LWP::RobotUA is a sub-class of L<LWP::UserAgent> and implements the
-same methods. In addition the following methods are provided:
-
-=head2 new
-
- my $ua = LWP::RobotUA->new( %options )
- my $ua = LWP::RobotUA->new( $agent, $from )
- my $ua = LWP::RobotUA->new( $agent, $from, $rules )
-
-The LWP::UserAgent options C<agent> and C<from> are mandatory. The
-options C<delay>, C<use_sleep> and C<rules> initialize attributes
-private to the RobotUA. If C<rules> are not provided, then
-L<WWW::RobotRules> is instantiated providing an internal database of
-F<robots.txt>.
-
-It is also possible to just pass the value of C<agent>, C<from> and
-optionally C<rules> as plain positional arguments.
-
-=head2 delay
-
- my $delay = $ua->delay;
- $ua->delay( $minutes );
-
-Get/set the minimum delay between requests to the same server, in
-I<minutes>. The default is C<1> minute. Note that this number doesn't
-have to be an integer; for example, this sets the delay to C<10> seconds:
-
- $ua->delay(10/60);
-
-=head2 use_sleep
-
- my $bool = $ua->use_sleep;
- $ua->use_sleep( $boolean );
-
-Get/set a value indicating whether the UA should L<LWP::RobotUA/sleep> if
-requests arrive too fast, defined as C<< $ua->delay >> minutes not passed since
-last request to the given server. The default is true. If this value is
-false then an internal C<SERVICE_UNAVAILABLE> response will be generated.
-It will have a C<Retry-After> header that indicates when it is OK to
-send another request to this server.
-
-=head2 rules
-
- my $rules = $ua->rules;
- $ua->rules( $rules );
-
-Set/get which I<WWW::RobotRules> object to use.
-
-=head2 no_visits
-
- my $num = $ua->no_visits( $netloc )
-
-Returns the number of documents fetched from this server host. Yeah I
-know, this method should probably have been named C<num_visits> or
-something like that. :-(
-
-=head2 host_wait
-
- my $num = $ua->host_wait( $netloc )
-
-Returns the number of I<seconds> (from now) you must wait before you can
-make a new request to this host.
-
-=head2 as_string
-
- my $string = $ua->as_string;
-
-Returns a string that describes the state of the UA.
-Mainly useful for debugging.
-
-=head1 SEE ALSO
-
-L<LWP::UserAgent>, L<WWW::RobotRules>
-
-=head1 COPYRIGHT
-
-Copyright 1996-2004 Gisle Aas.
-
-This library is free software; you can redistribute it and/or
-modify it under the same terms as Perl itself.
-
-=cut
diff --git a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Simple.pm b/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Simple.pm
deleted file mode 100644
index d76d6afdfd..0000000000
--- a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/Simple.pm
+++ /dev/null
@@ -1,267 +0,0 @@
-package LWP::Simple;
-
-use strict;
-
-our $VERSION = '6.61';
-
-require Exporter;
-
-our @EXPORT = qw(get head getprint getstore mirror);
-our @EXPORT_OK = qw($ua);
-
-# I really hate this. It was a bad idea to do it in the first place.
-# Wonder how to get rid of it??? (It even makes LWP::Simple 7% slower
-# for trivial tests)
-use HTTP::Status;
-push(@EXPORT, @HTTP::Status::EXPORT);
-
-sub import
-{
- my $pkg = shift;
- my $callpkg = caller;
- Exporter::export($pkg, $callpkg, @_);
-}
-
-use LWP::UserAgent ();
-use HTTP::Date ();
-
-our $ua = LWP::UserAgent->new; # we create a global UserAgent object
-$ua->agent("LWP::Simple/$VERSION ");
-$ua->env_proxy;
-
-sub get ($)
-{
- my $response = $ua->get(shift);
- return $response->decoded_content if $response->is_success;
- return undef;
-}
-
-
-sub head ($)
-{
- my($url) = @_;
- my $request = HTTP::Request->new(HEAD => $url);
- my $response = $ua->request($request);
-
- if ($response->is_success) {
- return $response unless wantarray;
- return (scalar $response->header('Content-Type'),
- scalar $response->header('Content-Length'),
- HTTP::Date::str2time($response->header('Last-Modified')),
- HTTP::Date::str2time($response->header('Expires')),
- scalar $response->header('Server'),
- );
- }
- return;
-}
-
-
-sub getprint ($)
-{
- my($url) = @_;
- my $request = HTTP::Request->new(GET => $url);
- local($\) = ""; # ensure standard $OUTPUT_RECORD_SEPARATOR
- my $callback = sub { print $_[0] };
- if ($^O eq "MacOS") {
- $callback = sub { $_[0] =~ s/\015?\012/\n/g; print $_[0] }
- }
- my $response = $ua->request($request, $callback);
- unless ($response->is_success) {
- print STDERR $response->status_line, " <URL:$url>\n";
- }
- $response->code;
-}
-
-
-sub getstore ($$)
-{
- my($url, $file) = @_;
- my $request = HTTP::Request->new(GET => $url);
- my $response = $ua->request($request, $file);
-
- $response->code;
-}
-
-
-sub mirror ($$)
-{
- my($url, $file) = @_;
- my $response = $ua->mirror($url, $file);
- $response->code;
-}
-
-
-1;
-
-__END__
-
-=pod
-
-=head1 NAME
-
-LWP::Simple - simple procedural interface to LWP
-
-=head1 SYNOPSIS
-
- perl -MLWP::Simple -e 'getprint "http://www.sn.no"'
-
- use LWP::Simple;
- $content = get("http://www.sn.no/");
- die "Couldn't get it!" unless defined $content;
-
- if (mirror("http://www.sn.no/", "foo") == RC_NOT_MODIFIED) {
- ...
- }
-
- if (is_success(getprint("http://www.sn.no/"))) {
- ...
- }
-
-=head1 DESCRIPTION
-
-This module is meant for people who want a simplified view of the
-libwww-perl library. It should also be suitable for one-liners. If
-you need more control or access to the header fields in the requests
-sent and responses received, then you should use the full object-oriented
-interface provided by the L<LWP::UserAgent> module.
-
-The module will also export the L<LWP::UserAgent> object as C<$ua> if you
-ask for it explicitly.
-
-The user agent created by this module will identify itself as
-C<LWP::Simple/#.##>
-and will initialize its proxy defaults from the environment (by
-calling C<< $ua->env_proxy >>).
-
-=head1 FUNCTIONS
-
-The following functions are provided (and exported) by this module:
-
-=head2 get
-
- my $res = get($url);
-
-The get() function will fetch the document identified by the given URL
-and return it. It returns C<undef> if it fails. The C<$url> argument can
-be either a string or a reference to a L<URI> object.
-
-You will not be able to examine the response code or response headers
-(like C<Content-Type>) when you are accessing the web using this
-function. If you need that information you should use the full OO
-interface (see L<LWP::UserAgent>).
-
-=head2 head
-
- my $res = head($url);
-
-Get document headers. Returns the following 5 values if successful:
-($content_type, $document_length, $modified_time, $expires, $server)
-
-Returns an empty list if it fails. In scalar context returns TRUE if
-successful.
-
-=head2 getprint
-
- my $code = getprint($url);
-
-Get and print a document identified by a URL. The document is printed
-to the selected default filehandle for output (normally STDOUT) as
-data is received from the network. If the request fails, then the
-status code and message are printed on STDERR. The return value is
-the HTTP response code.
-
-=head2 getstore
-
- my $code = getstore($url, $file)
-
-Gets a document identified by a URL and stores it in the file. The
-return value is the HTTP response code.
-
-=head2 mirror
-
- my $code = mirror($url, $file);
-
-Get and store a document identified by a URL, using
-I<If-modified-since>, and checking the I<Content-Length>. Returns
-the HTTP response code.
-
-=head1 STATUS CONSTANTS
-
-This module also exports the L<HTTP::Status> constants and procedures.
-You can use them when you check the response code from L<LWP::Simple/getprint>,
-L<LWP::Simple/getstore> or L<LWP::Simple/mirror>. The constants are:
-
- RC_CONTINUE
- RC_SWITCHING_PROTOCOLS
- RC_OK
- RC_CREATED
- RC_ACCEPTED
- RC_NON_AUTHORITATIVE_INFORMATION
- RC_NO_CONTENT
- RC_RESET_CONTENT
- RC_PARTIAL_CONTENT
- RC_MULTIPLE_CHOICES
- RC_MOVED_PERMANENTLY
- RC_MOVED_TEMPORARILY
- RC_SEE_OTHER
- RC_NOT_MODIFIED
- RC_USE_PROXY
- RC_BAD_REQUEST
- RC_UNAUTHORIZED
- RC_PAYMENT_REQUIRED
- RC_FORBIDDEN
- RC_NOT_FOUND
- RC_METHOD_NOT_ALLOWED
- RC_NOT_ACCEPTABLE
- RC_PROXY_AUTHENTICATION_REQUIRED
- RC_REQUEST_TIMEOUT
- RC_CONFLICT
- RC_GONE
- RC_LENGTH_REQUIRED
- RC_PRECONDITION_FAILED
- RC_REQUEST_ENTITY_TOO_LARGE
- RC_REQUEST_URI_TOO_LARGE
- RC_UNSUPPORTED_MEDIA_TYPE
- RC_INTERNAL_SERVER_ERROR
- RC_NOT_IMPLEMENTED
- RC_BAD_GATEWAY
- RC_SERVICE_UNAVAILABLE
- RC_GATEWAY_TIMEOUT
- RC_HTTP_VERSION_NOT_SUPPORTED
-
-=head1 CLASSIFICATION FUNCTIONS
-
-The L<HTTP::Status> classification functions are:
-
-=head2 is_success
-
- my $bool = is_success($rc);
-
-True if response code indicated a successful request.
-
-=head2 is_error
-
- my $bool = is_error($rc)
-
-True if response code indicated that an error occurred.
-
-=head1 CAVEAT
-
-Note that if you are using both LWP::Simple and the very popular L<CGI>
-module, you may be importing a C<head> function from each module,
-producing a warning like C<Prototype mismatch: sub main::head ($) vs none>.
-Get around this problem by just not importing LWP::Simple's
-C<head> function, like so:
-
- use LWP::Simple qw(!head);
- use CGI qw(:standard); # then only CGI.pm defines a head()
-
-Then if you do need LWP::Simple's C<head> function, you can just call
-it as C<LWP::Simple::head($url)>.
-
-=head1 SEE ALSO
-
-L<LWP>, L<lwpcook>, L<LWP::UserAgent>, L<HTTP::Status>, L<lwp-request>,
-L<lwp-mirror>
-
-=cut
diff --git a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/UserAgent.pm b/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/UserAgent.pm
deleted file mode 100644
index a521f16529..0000000000
--- a/systems/texlive/tlnet/tlpkg/tlperl/site/lib/LWP/UserAgent.pm
+++ /dev/null
@@ -1,2179 +0,0 @@
-package LWP::UserAgent;
-
-use strict;
-
-use parent qw(LWP::MemberMixin);
-
-use Carp ();
-use File::Copy ();
-use HTTP::Request ();
-use HTTP::Response ();
-use HTTP::Date ();
-
-use LWP ();
-use HTTP::Status ();
-use LWP::Protocol ();
-
-use Scalar::Util qw(blessed);
-use Try::Tiny qw(try catch);
-
-our $VERSION = '6.61';
-
-sub new
-{
- # Check for common user mistake
- Carp::croak("Options to LWP::UserAgent should be key/value pairs, not hash reference")
- if ref($_[1]) eq 'HASH';
-
- my($class, %cnf) = @_;
-
- my $agent = delete $cnf{agent};
- my $from = delete $cnf{from};
- my $def_headers = delete $cnf{default_headers};
- my $timeout = delete $cnf{timeout};
- $timeout = 3*60 unless defined $timeout;
- my $local_address = delete $cnf{local_address};
- my $ssl_opts = delete $cnf{ssl_opts} || {};
- unless (exists $ssl_opts->{verify_hostname}) {
- # The processing of HTTPS_CA_* below is for compatibility with Crypt::SSLeay
- if (exists $ENV{PERL_LWP_SSL_VERIFY_HOSTNAME}) {
- $ssl_opts->{verify_hostname} = $ENV{PERL_LWP_SSL_VERIFY_HOSTNAME};
- }
- elsif ($ENV{HTTPS_CA_FILE} || $ENV{HTTPS_CA_DIR}) {
- # Crypt-SSLeay compatibility (verify peer certificate; but not the hostname)
- $ssl_opts->{verify_hostname} = 0;
- $ssl_opts->{SSL_verify_mode} = 1;
- }
- else {
- $ssl_opts->{verify_hostname} = 1;
- }
- }
- unless (exists $ssl_opts->{SSL_ca_file}) {
- if (my $ca_file = $ENV{PERL_LWP_SSL_CA_FILE} || $ENV{HTTPS_CA_FILE}) {
- $ssl_opts->{SSL_ca_file} = $ca_file;
- }
- }
- unless (exists $ssl_opts->{SSL_ca_path}) {
- if (my $ca_path = $ENV{PERL_LWP_SSL_CA_PATH} || $ENV{HTTPS_CA_DIR}) {
- $ssl_opts->{SSL_ca_path} = $ca_path;
- }
- }
- my $use_eval = delete $cnf{use_eval};
- $use_eval = 1 unless defined $use_eval;
- my $parse_head = delete $cnf{parse_head};
- $parse_head = 1 unless defined $parse_head;
- my $send_te = delete $cnf{send_te};
- $send_te = 1 unless defined $send_te;
- my $show_progress = delete $cnf{show_progress};
- my $max_size = delete $cnf{max_size};
- my $max_redirect = delete $cnf{max_redirect};
- $max_redirect = 7 unless defined $max_redirect;
- my $env_proxy = exists $cnf{env_proxy} ? delete $cnf{env_proxy} : $ENV{PERL_LWP_ENV_PROXY};
- my $no_proxy = exists $cnf{no_proxy} ? delete $cnf{no_proxy} : [];
- Carp::croak(qq{no_proxy must be an arrayref, not $no_proxy!}) if ref $no_proxy ne 'ARRAY';
-
- my $cookie_jar = delete $cnf{cookie_jar};
- my $conn_cache = delete $cnf{conn_cache};
- my $keep_alive = delete $cnf{keep_alive};
-
- Carp::croak("Can't mix conn_cache and keep_alive")
- if $conn_cache && $keep_alive;
-
- my $protocols_allowed = delete $cnf{protocols_allowed};
- my $protocols_forbidden = delete $cnf{protocols_forbidden};
-
- my $requests_redirectable = delete $cnf{requests_redirectable};
- $requests_redirectable = ['GET', 'HEAD']
- unless defined $requests_redirectable;
-
- # Actually ""s are just as good as 0's, but for concision we'll just say:
- Carp::croak("protocols_allowed has to be an arrayref or 0, not \"$protocols_allowed\"!")
- if $protocols_allowed and ref($protocols_allowed) ne 'ARRAY';
- Carp::croak("protocols_forbidden has to be an arrayref or 0, not \"$protocols_forbidden\"!")
- if $protocols_forbidden and ref($protocols_forbidden) ne 'ARRAY';
- Carp::croak("requests_redirectable has to be an arrayref or 0, not \"$requests_redirectable\"!")
- if $requests_redirectable and ref($requests_redirectable) ne 'ARRAY';
-
- if (%cnf && $^W) {
- Carp::carp("Unrecognized LWP::UserAgent options: @{[sort keys %cnf]}");
- }
-
- my $self = bless {
- def_headers => $def_headers,
- timeout => $timeout,
- local_address => $local_address,
- ssl_opts => $ssl_opts,
- use_eval => $use_eval,
- show_progress => $show_progress,
- max_size => $max_size,
- max_redirect => $max_redirect,
- # We set proxy later as we do validation on the values
- proxy => {},
- no_proxy => [ @{ $no_proxy } ],
- protocols_allowed => $protocols_allowed,
- protocols_forbidden => $protocols_forbidden,
- requests_redirectable => $requests_redirectable,
- send_te => $send_te,
- }, $class;
-
- $self->agent(defined($agent) ? $agent : $class->_agent)
- if defined($agent) || !$def_headers || !$def_headers->header("User-Agent");
- $self->from($from) if $from;
- $self->cookie_jar($cookie_jar) if $cookie_jar;
- $self->parse_head($parse_head);
- $self->env_proxy if $env_proxy;
-
- if (exists $cnf{proxy}) {
- Carp::croak(qq{proxy must be an arrayref, not $cnf{proxy}!})
- if ref $cnf{proxy} ne 'ARRAY';
- $self->proxy($cnf{proxy});
- }
-
- $self->protocols_allowed( $protocols_allowed ) if $protocols_allowed;
- $self->protocols_forbidden($protocols_forbidden) if $protocols_forbidden;
-
- if ($keep_alive) {
- $conn_cache ||= { total_capacity => $keep_alive };
- }
- $self->conn_cache($conn_cache) if $conn_cache;
-
- return $self;
-}
-
-
-sub send_request
-{
- my($self, $request, $arg, $size) = @_;
- my($method, $url) = ($request->method, $request->uri);
- my $scheme = $url->scheme;
-
- local($SIG{__DIE__}); # protect against user defined die handlers
-
- $self->progress("begin", $request);
-
- my $response = $self->run_handlers("request_send", $request);
-
- unless ($response) {
- my $protocol;
-
- {
- # Honor object-specific restrictions by forcing protocol objects
- # into class LWP::Protocol::nogo.
- my $x;
- if($x = $self->protocols_allowed) {
- if (grep lc($_) eq $scheme, @$x) {
- }
- else {
- require LWP::Protocol::nogo;
- $protocol = LWP::Protocol::nogo->new;
- }
- }
- elsif ($x = $self->protocols_forbidden) {
- if(grep lc($_) eq $scheme, @$x) {
- require LWP::Protocol::nogo;
- $protocol = LWP::Protocol::nogo->new;
- }
- }
- # else fall thru and create the protocol object normally
- }
-
- # Locate protocol to use
- my $proxy = $request->{proxy};
- if ($proxy) {
- $scheme = $proxy->scheme;
- }
-
- unless ($protocol) {
- try {
- $protocol = LWP::Protocol::create($scheme, $self);
- }
- catch {
- my $error = $_;
- $error =~ s/ at .* line \d+.*//s; # remove file/line number
- $response = _new_response($request, HTTP::Status::RC_NOT_IMPLEMENTED, $error);
- if ($scheme eq "https") {
- $response->message($response->message . " (LWP::Protocol::https not installed)");
- $response->content_type("text/plain");
- $response->content(<<EOT);
-LWP will support https URLs if the LWP::Protocol::https module
-is installed.
-EOT
- }
- };
- }
-
- if (!$response && $self->{use_eval}) {
- # we eval, and turn dies into responses below
- try {
- $response = $protocol->request($request, $proxy, $arg, $size, $self->{timeout}) || die "No response returned by $protocol";
- }
- catch {
- my $error = $_;
- if (blessed($error) && $error->isa("HTTP::Response")) {
- $response = $error;
- $response->request($request);
- }
- else {
- my $full = $error;
- (my $status = $error) =~ s/\n.*//s;
- $status =~ s/ at .* line \d+.*//s; # remove file/line number
- my $code = ($status =~ s/^(\d\d\d)\s+//) ? $1 : HTTP::Status::RC_INTERNAL_SERVER_ERROR;
- $response = _new_response($request, $code, $status, $full);
- }
- };
- }
- elsif (!$response) {
- $response = $protocol->request($request, $proxy,
- $arg, $size, $self->{timeout});
- # XXX: Should we die unless $response->is_success ???
- }
- }
-
- $response->request($request); # record request for reference
- $response->header("Client-Date" => HTTP::Date::time2str(time));
-
- $self->run_handlers("response_done", $response);
-
- $self->progress("end", $response);
- return $response;
-}
-
-
-sub prepare_request
-{
- my($self, $request) = @_;
- die "Method missing" unless $request->method;
- my $url = $request->uri;
- die "URL missing" unless $url;
- die "URL must be absolute" unless $url->scheme;
-
- $self->run_handlers("request_preprepare", $request);
-
- if (my $def_headers = $self->{def_headers}) {
- for my $h ($def_headers->header_field_names) {
- $request->init_header($h => [$def_headers->header($h)]);
- }
- }
-
- $self->run_handlers("request_prepare", $request);
-
- return $request;
-}
-
-
-sub simple_request
-{
- my($self, $request, $arg, $size) = @_;
-
- # sanity check the request passed in
- if (defined $request) {
- if (ref $request) {
- Carp::croak("You need a request object, not a " . ref($request) . " object")
- if ref($request) eq 'ARRAY' or ref($request) eq 'HASH' or
- !$request->can('method') or !$request->can('uri');
- }
- else {
- Carp::croak("You need a request object, not '$request'");
- }
- }
- else {
- Carp::croak("No request object passed in");
- }
-
- my $error;
- try {
- $request = $self->prepare_request($request);
- }
- catch {
- $error = $_;
- $error =~ s/ at .* line \d+.*//s; # remove file/line number
- };
-
- if ($error) {
- return _new_response($request, HTTP::Status::RC_BAD_REQUEST, $error);
- }
- return $self->send_request($request, $arg, $size);
-}
-
-
-sub request {
- my ($self, $request, $arg, $size, $previous) = @_;
-
- my $response = $self->simple_request($request, $arg, $size);
- $response->previous($previous) if $previous;
-
- if ($response->redirects >= $self->{max_redirect}) {
- if ($response->header('Location')) {
- $response->header("Client-Warning" =>
- "Redirect loop detected (max_redirect = $self->{max_redirect})"
- );
- }
- return $response;
- }
-
- if (my $req = $self->run_handlers("response_redirect", $response)) {
- return $self->request($req, $arg, $size, $response);
- }
-
- my $code = $response->code;
-
- if ( $code == HTTP::Status::RC_MOVED_PERMANENTLY
- or $code == HTTP::Status::RC_FOUND
- or $code == HTTP::Status::RC_SEE_OTHER
- or $code == HTTP::Status::RC_TEMPORARY_REDIRECT
- or $code == HTTP::Status::RC_PERMANENT_REDIRECT)
- {
- my $referral = $request->clone;
-
- # These headers should never be forwarded
- $referral->remove_header('Host', 'Cookie');
-
- if ( $referral->header('Referer')
- && $request->uri->scheme eq 'https'
- && $referral->uri->scheme eq 'http')
- {
- # RFC 2616, section 15.1.3.
- # https -> http redirect, suppressing Referer
- $referral->remove_header('Referer');
- }
-
- if ( $code == HTTP::Status::RC_SEE_OTHER
- || $code == HTTP::Status::RC_FOUND)
- {
- my $method = uc($referral->method);
- unless ($method eq "GET" || $method eq "HEAD") {
- $referral->method("GET");
- $referral->content("");
- $referral->remove_content_headers;
- }
- }
-
- # And then we update the URL based on the Location:-header.
- my $referral_uri = $response->header('Location');
- {
- # Some servers erroneously return a relative URL for redirects,
- # so make it absolute if it not already is.
- local $URI::ABS_ALLOW_RELATIVE_SCHEME = 1;
- my $base = $response->base;
- $referral_uri = "" unless defined $referral_uri;
- $referral_uri
- = $HTTP::URI_CLASS->new($referral_uri, $base)->abs($base);
- }
- $referral->uri($referral_uri);
-
- return $response unless $self->redirect_ok($referral, $response);
- return $self->request($referral, $arg, $size, $response);
-
- }
- elsif ($code == HTTP::Status::RC_UNAUTHORIZED
- || $code == HTTP::Status::RC_PROXY_AUTHENTICATION_REQUIRED)
- {
- my $proxy = ($code == HTTP::Status::RC_PROXY_AUTHENTICATION_REQUIRED);
- my $ch_header
- = $proxy || $request->method eq 'CONNECT'
- ? "Proxy-Authenticate"
- : "WWW-Authenticate";
- my @challenges = $response->header($ch_header);
- unless (@challenges) {
- $response->header(
- "Client-Warning" => "Missing Authenticate header");
- return $response;
- }
-
- require HTTP::Headers::Util;
- CHALLENGE: for my $challenge (@challenges) {
- $challenge =~ tr/,/;/; # "," is used to separate auth-params!!
- ($challenge) = HTTP::Headers::Util::split_header_words($challenge);
- my $scheme = shift(@$challenge);
- shift(@$challenge); # no value
- $challenge = {@$challenge}; # make rest into a hash
-
- unless ($scheme =~ /^([a-z]+(?:-[a-z]+)*)$/) {
- $response->header(
- "Client-Warning" => "Bad authentication scheme '$scheme'");
- return $response;
- }
- $scheme = $1; # untainted now
- my $class = "LWP::Authen::\u$scheme";
- $class =~ tr/-/_/;
-
- no strict 'refs';
- unless (%{"$class\::"}) {
- # try to load it
- my $error;
- try {
- (my $req = $class) =~ s{::}{/}g;
- $req .= '.pm' unless $req =~ /\.pm$/;
- require $req;
- }
- catch {
- $error = $_;
- };
- if ($error) {
- if ($error =~ /^Can\'t locate/) {
- $response->header("Client-Warning" =>
- "Unsupported authentication scheme '$scheme'");
- }
- else {
- $response->header("Client-Warning" => $error);
- }
- next CHALLENGE;
- }
- }
- unless ($class->can("authenticate")) {
- $response->header("Client-Warning" =>
- "Unsupported authentication scheme '$scheme'");
- next CHALLENGE;
- }
- my $re = $class->authenticate($self, $proxy, $challenge, $response,
- $request, $arg, $size);
-
- next CHALLENGE if $re->code == HTTP::Status::RC_UNAUTHORIZED;
- return $re;
- }
- return $response;
- }
- return $response;
-}
-
-#
-# Now the shortcuts...
-#
-sub get {
- require HTTP::Request::Common;
- my($self, @parameters) = @_;
- my @suff = $self->_process_colonic_headers(\@parameters,1);
- return $self->request( HTTP::Request::Common::GET( @parameters ), @suff );
-}
-
-sub _maybe_copy_default_content_type {
- my $self = shift;
- my $req = shift;
-
- my $default_ct = $self->default_header('Content-Type');
- return unless defined $default_ct;
-
- # drop url
- shift;
-
- # adapted from HTTP::Request::Common::request_type_with_data
- my $content;
- $content = shift if @_ and ref $_[0];
-
- # We only care about the final value, really
- my $ct;
-
- my ($k, $v);
- while (($k, $v) = splice(@_, 0, 2)) {
- if (lc($k) eq 'content') {
- $content = $v;
- }
- elsif (lc($k) eq 'content-type') {
- $ct = $v;
- }
- }
-
- # Content-type provided and truthy? skip
- return if $ct;
-
- # Content is not just a string? Then it must be x-www-form-urlencoded
- return if defined $content && ref($content);
-
- # Provide default
- $req->header('Content-Type' => $default_ct);
-}
-
-sub post {
- require HTTP::Request::Common;
- my($self, @parameters) = @_;
- my @suff = $self->_process_colonic_headers(\@parameters, (ref($parameters[1]) ? 2 : 1));
- my $req = HTTP::Request::Common::POST(@parameters);
- $self->_maybe_copy_default_content_type($req, @parameters);
- return $self->request($req, @suff);
-}
-
-
-sub head {
- require HTTP::Request::Common;
- my($self, @parameters) = @_;
- my @suff = $self->_process_colonic_headers(\@parameters,1);
- return $self->request( HTTP::Request::Common::HEAD( @parameters ), @suff );
-}
-
-sub patch {
- require HTTP::Request::Common;
- my($self, @parameters) = @_;
- my @suff = $self->_process_colonic_headers(\@parameters, (ref($parameters[1]) ? 2 : 1));
-
- # this work-around is in place as HTTP::Request::Common
- # did not implement a patch convenience method until
- # version 6.12. Once we can bump the prereq to at least
- # that version, we can use ::PATCH instead of this hack
- my $req = HTTP::Request::Common::PUT(@parameters);
- $req->method('PATCH');
-
- $self->_maybe_copy_default_content_type($req, @parameters);
- return $self->request($req, @suff);
-}
-
-sub put {
- require HTTP::Request::Common;
- my($self, @parameters) = @_;
- my @suff = $self->_process_colonic_headers(\@parameters, (ref($parameters[1]) ? 2 : 1));
- my $req = HTTP::Request::Common::PUT(@parameters);
- $self->_maybe_copy_default_content_type($req, @parameters);
- return $self->request($req, @suff);
-}
-
-
-sub delete {
- require HTTP::Request::Common;
- my($self, @parameters) = @_;
- my @suff = $self->_process_colonic_headers(\@parameters,1);
- return $self->request( HTTP::Request::Common::DELETE( @parameters ), @suff );
-}
-
-
-sub _process_colonic_headers {
- # Process :content_cb / :content_file / :read_size_hint headers.
- my($self, $args, $start_index) = @_;
-
- my($arg, $size);
- for(my $i = $start_index; $i < @$args; $i += 2) {
- next unless defined $args->[$i];
-
- #printf "Considering %s => %s\n", $args->[$i], $args->[$i + 1];
-
- if($args->[$i] eq ':content_cb') {
- # Some sanity-checking...
- $arg = $args->[$i + 1];
- Carp::croak("A :content_cb value can't be undef") unless defined $arg;
- Carp::croak("A :content_cb value must be a coderef")
- unless ref $arg and UNIVERSAL::isa($arg, 'CODE');
-
- }
- elsif ($args->[$i] eq ':content_file') {
- $arg = $args->[$i + 1];
-
- # Some sanity-checking...
- Carp::croak("A :content_file value can't be undef")
- unless defined $arg;
- Carp::croak("A :content_file value can't be a reference")
- if ref $arg;
- Carp::croak("A :content_file value can't be \"\"")
- unless length $arg;
-
- }
- elsif ($args->[$i] eq ':read_size_hint') {
- $size = $args->[$i + 1];
- # Bother checking it?
-
- }
- else {
- next;
- }
- splice @$args, $i, 2;
- $i -= 2;
- }
-
- # And return a suitable suffix-list for request(REQ,...)
-
- return unless defined $arg;
- return $arg, $size if defined $size;
- return $arg;
-}
-
-
-sub is_online {
- my $self = shift;
- return 1 if $self->get("http://www.msftncsi.com/ncsi.txt")->content eq "Microsoft NCSI";
- return 1 if $self->get("http://www.apple.com")->content =~ m,<title>Apple</title>,;
- return 0;
-}
-
-
-my @ANI = qw(- \ | /);
-
-sub progress {
- my($self, $status, $m) = @_;
- return unless $self->{show_progress};
-
- local($,, $\);
- if ($status eq "begin") {
- print STDERR "** ", $m->method, " ", $m->uri, " ==> ";
- $self->{progress_start} = time;
- $self->{progress_lastp} = "";
- $self->{progress_ani} = 0;
- }
- elsif ($status eq "end") {
- delete $self->{progress_lastp};
- delete $self->{progress_ani};
- print STDERR $m->status_line;
- my $t = time - delete $self->{progress_start};
- print STDERR " (${t}s)" if $t;
- print STDERR "\n";
- }
- elsif ($status eq "tick") {
- print STDERR "$ANI[$self->{progress_ani}++]\b";
- $self->{progress_ani} %= @ANI;
- }
- else {
- my $p = sprintf "%3.0f%%", $status * 100;
- return if $p eq $self->{progress_lastp};
- print STDERR "$p\b\b\b\b";
- $self->{progress_lastp} = $p;
- }
- STDERR->flush;
-}
-
-
-#
-# This whole allow/forbid thing is based on man 1 at's way of doing things.
-#
-sub is_protocol_supported
-{
- my($self, $scheme) = @_;
- if (ref $scheme) {
- # assume we got a reference to an URI object
- $scheme = $scheme->scheme;
- }
- else {
- Carp::croak("Illegal scheme '$scheme' passed to is_protocol_supported")
- if $scheme =~ /\W/;
- $scheme = lc $scheme;
- }
-
- my $x;
- if(ref($self) and $x = $self->protocols_allowed) {
- return 0 unless grep lc($_) eq $scheme, @$x;
- }
- elsif (ref($self) and $x = $self->protocols_forbidden) {
- return 0 if grep lc($_) eq $scheme, @$x;
- }
-
- local($SIG{__DIE__}); # protect against user defined die handlers
- $x = LWP::Protocol::implementor($scheme);
- return 1 if $x and $x ne 'LWP::Protocol::nogo';
- return 0;
-}
-
-
-sub protocols_allowed { shift->_elem('protocols_allowed' , @_) }
-sub protocols_forbidden { shift->_elem('protocols_forbidden' , @_) }
-sub requests_redirectable { shift->_elem('requests_redirectable', @_) }
-
-
-sub redirect_ok
-{
- # RFC 2616, section 10.3.2 and 10.3.3 say:
- # If the 30[12] status code is received in response to a request other
- # than GET or HEAD, the user agent MUST NOT automatically redirect the
- # request unless it can be confirmed by the user, since this might
- # change the conditions under which the request was issued.
-
- # Note that this routine used to be just:
- # return 0 if $_[1]->method eq "POST"; return 1;
-
- my($self, $new_request, $response) = @_;
- my $method = $response->request->method;
- return 0 unless grep $_ eq $method,
- @{ $self->requests_redirectable || [] };
-
- if ($new_request->uri->scheme eq 'file') {
- $response->header("Client-Warning" =>
- "Can't redirect to a file:// URL!");
- return 0;
- }
-
- # Otherwise it's apparently okay...
- return 1;
-}
-
-sub credentials {
- my $self = shift;
- my $netloc = lc(shift || '');
- my $realm = shift || "";
- my $old = $self->{basic_authentication}{$netloc}{$realm};
- if (@_) {
- $self->{basic_authentication}{$netloc}{$realm} = [@_];
- }
- return unless $old;
- return @$old if wantarray;
- return join(":", @$old);
-}
-
-sub get_basic_credentials
-{
- my($self, $realm, $uri, $proxy) = @_;
- return if $proxy;
- return $self->credentials($uri->host_port, $realm);
-}
-
-
-sub timeout { shift->_elem('timeout', @_); }
-sub local_address{ shift->_elem('local_address',@_); }
-sub max_size { shift->_elem('max_size', @_); }
-sub max_redirect { shift->_elem('max_redirect', @_); }
-sub show_progress{ shift->_elem('show_progress', @_); }
-sub send_te { shift->_elem('send_te', @_); }
-
-sub ssl_opts {
- my $self = shift;
- if (@_ == 1) {
- my $k = shift;
- return $self->{ssl_opts}{$k};
- }
- if (@_) {
- my $old;
- while (@_) {
- my($k, $v) = splice(@_, 0, 2);
- $old = $self->{ssl_opts}{$k} unless @_;
- if (defined $v) {
- $self->{ssl_opts}{$k} = $v;
- }
- else {
- delete $self->{ssl_opts}{$k};
- }
- }
- %{$self->{ssl_opts}} = (%{$self->{ssl_opts}}, @_);
- return $old;
- }
-
- my @opts= sort keys %{$self->{ssl_opts}};
- return @opts;
-}
-
-sub parse_head {
- my $self = shift;
- if (@_) {
- my $flag = shift;
- my $parser;
- my $old = $self->set_my_handler("response_header", $flag ? sub {
- my($response, $ua) = @_;
- require HTML::HeadParser;
- $parser = HTML::HeadParser->new;
- $parser->xml_mode(1) if $response->content_is_xhtml;
- $parser->utf8_mode(1) if $] >= 5.008 && $HTML::Parser::VERSION >= 3.40;
-
- push(@{$response->{handlers}{response_data}}, {
- callback => sub {
- return unless $parser;
- unless ($parser->parse($_[3])) {
- my $h = $parser->header;
- my $r = $_[0];
- for my $f ($h->header_field_names) {
- $r->init_header($f, [$h->header($f)]);
- }
- undef($parser);
- }
- },
- });
-
- } : undef,
- m_media_type => "html",
- );
- return !!$old;
- }
- else {
- return !!$self->get_my_handler("response_header");
- }
-}
-
-sub cookie_jar {
- my $self = shift;
- my $old = $self->{cookie_jar};
- if (@_) {
- my $jar = shift;
- if (ref($jar) eq "HASH") {
- require HTTP::Cookies;
- $jar = HTTP::Cookies->new(%$jar);
- }
- $self->{cookie_jar} = $jar;
- $self->set_my_handler("request_prepare",
- $jar ? sub {
- return if $_[0]->header("Cookie");
- $jar->add_cookie_header($_[0]);
- } : undef,
- );
- $self->set_my_handler("response_done",
- $jar ? sub { $jar->extract_cookies($_[0]); } : undef,
- );
- }
- $old;
-}
-
-sub default_headers {
- my $self = shift;
- my $old = $self->{def_headers} ||= HTTP::Headers->new;
- if (@_) {
- Carp::croak("default_headers not set to HTTP::Headers compatible object")
- unless @_ == 1 && $_[0]->can("header_field_names");
- $self->{def_headers} = shift;
- }
- return $old;
-}
-
-sub default_header {
- my $self = shift;
- return $self->default_headers->header(@_);
-}
-
-sub _agent { "libwww-perl/$VERSION" }
-
-sub agent {
- my $self = shift;
- if (@_) {
- my $agent = shift;
- if ($agent) {
- $agent .= $self->_agent if $agent =~ /\s+$/;
- }
- else {
- undef($agent)
- }
- return $self->default_header("User-Agent", $agent);
- }
- return $self->default_header("User-Agent");
-}
-
-sub from { # legacy
- my $self = shift;
- return $self->default_header("From", @_);
-}
-
-
-sub conn_cache {
- my $self = shift;
- my $old = $self->{conn_cache};
- if (@_) {
- my $cache = shift;
- if (ref($cache) eq "HASH") {
- require LWP::ConnCache;
- $cache = LWP::ConnCache->new(%$cache);
- }
- $self->{conn_cache} = $cache;
- }
- $old;
-}
-
-
-sub add_handler {
- my($self, $phase, $cb, %spec) = @_;
- $spec{line} ||= join(":", (caller)[1,2]);
- my $conf = $self->{handlers}{$phase} ||= do {
- require HTTP::Config;
- HTTP::Config->new;
- };
- $conf->add(%spec, callback => $cb);
-}
-
-sub set_my_handler {
- my($self, $phase, $cb, %spec) = @_;
- $spec{owner} = (caller(1))[3] unless exists $spec{owner};
- $self->remove_handler($phase, %spec);
- $spec{line} ||= join(":", (caller)[1,2]);
- $self->add_handler($phase, $cb, %spec) if $cb;
-}
-
-sub get_my_handler {
- my $self = shift;
- my $phase = shift;
- my $init = pop if @_ % 2;
- my %spec = @_;
- my $conf = $self->{handlers}{$phase};
- unless ($conf) {
- return unless $init;
- require HTTP::Config;
- $conf = $self->{handlers}{$phase} = HTTP::Config->new;
- }
- $spec{owner} = (caller(1))[3] unless exists $spec{owner};
- my @h = $conf->find(%spec);
- if (!@h && $init) {
- if (ref($init) eq "CODE") {
- $init->(\%spec);
- }
- elsif (ref($init) eq "HASH") {
- $spec{$_}= $init->{$_}
- for keys %$init;
- }
- $spec{callback} ||= sub {};
- $spec{line} ||= join(":", (caller)[1,2]);
- $conf->add(\%spec);
- return \%spec;
- }
- return wantarray ? @h : $h[0];
-}
-
-sub remove_handler {
- my($self, $phase, %spec) = @_;
- if ($phase) {
- my $conf = $self->{handlers}{$phase} || return;
- my @h = $conf->remove(%spec);
- delete $self->{handlers}{$phase} if $conf->empty;
- return @h;
- }
-
- return unless $self->{handlers};
- return map $self->remove_handler($_), sort keys %{$self->{handlers}};
-}
-
-sub handlers {
- my($self, $phase, $o) = @_;
- my @h;
- if ($o->{handlers} && $o->{handlers}{$phase}) {
- push(@h, @{$o->{handlers}{$phase}});
- }
- if (my $conf = $self->{handlers}{$phase}) {
- push(@h, $conf->matching($o));
- }
- return @h;
-}
-
-sub run_handlers {
- my($self, $phase, $o) = @_;
-
- # here we pass $_[2] to the callbacks, instead of $o, so that they
- # can assign to it; e.g. request_prepare is documented to allow
- # that
- if (defined(wantarray)) {
- for my $h ($self->handlers($phase, $o)) {
- my $ret = $h->{callback}->($_[2], $self, $h);
- return $ret if $ret;
- }
- return undef;
- }
-
- for my $h ($self->handlers($phase, $o)) {
- $h->{callback}->($_[2], $self, $h);
- }
-}
-
-
-# deprecated
-sub use_eval { shift->_elem('use_eval', @_); }
-sub use_alarm
-{
- Carp::carp("LWP::UserAgent->use_alarm(BOOL) is a no-op")
- if @_ > 1 && $^W;
- "";
-}
-
-
-sub clone
-{
- my $self = shift;
- my $copy = bless { %$self }, ref $self; # copy most fields
-
- delete $copy->{handlers};
- delete $copy->{conn_cache};
-
- # copy any plain arrays and hashes; known not to need recursive copy
- for my $k (qw(proxy no_proxy requests_redirectable ssl_opts)) {
- next unless $copy->{$k};
- if (ref($copy->{$k}) eq "ARRAY") {
- $copy->{$k} = [ @{$copy->{$k}} ];
- }
- elsif (ref($copy->{$k}) eq "HASH") {
- $copy->{$k} = { %{$copy->{$k}} };
- }
- }
-
- if ($self->{def_headers}) {
- $copy->{def_headers} = $self->{def_headers}->clone;
- }
-
- # re-enable standard handlers
- $copy->parse_head($self->parse_head);
-
- # no easy way to clone the cookie jar; so let's just remove it for now
- $copy->cookie_jar(undef);
-
- $copy;
-}
-
-
-sub mirror
-{
- my($self, $url, $file) = @_;
-
- die "Local file name is missing" unless defined $file && length $file;
-
- my $request = HTTP::Request->new('GET', $url);
-
- # If the file exists, add a cache-related header
- if ( -e $file ) {
- my ($mtime) = ( stat($file) )[9];
- if ($mtime) {
- $request->header( 'If-Modified-Since' => HTTP::Date::time2str($mtime) );
- }
- }
-
- require File::Temp;
- my ($tmpfh, $tmpfile) = File::Temp::tempfile("$file-XXXXXX");
- close($tmpfh) or die "Could not close tmpfile '$tmpfile': $!";
-
- my $response = $self->request($request, $tmpfile);
- if ( $response->header('X-Died') ) {
- unlink($tmpfile);
- die $response->header('X-Died');
- }
-
- # Only fetching a fresh copy of the file would be considered success.
- # If the file was not modified, "304" would returned, which
- # is considered by HTTP::Status to be a "redirect", /not/ "success"
- if ( $response->is_success ) {
- my @stat = stat($tmpfile) or die "Could not stat tmpfile '$tmpfile': $!";
- my $file_length = $stat[7];
- my ($content_length) = $response->header('Content-length');
-
- if ( defined $content_length and $file_length < $content_length ) {
- unlink($tmpfile);
- die "Transfer truncated: only $file_length out of $content_length bytes received\n";
- }
- elsif ( defined $content_length and $file_length > $content_length ) {
- unlink($tmpfile);
- die "Content-length mismatch: expected $content_length bytes, got $file_length\n";
- }
- # The file was the expected length.
- else {
- # Replace the stale file with a fresh copy
- # File::Copy will attempt to do it atomically,
- # and fall back to a delete + copy if that fails.
- File::Copy::move( $tmpfile, $file )
- or die "Cannot rename '$tmpfile' to '$file': $!\n";
-
- # Set standard file permissions if umask is supported.
- # If not, leave what File::Temp created in effect.
- if ( defined(my $umask = umask()) ) {
- my $mode = 0666 &~ $umask;
- chmod $mode, $file
- or die sprintf("Cannot chmod %o '%s': %s\n", $mode, $file, $!);
- }
-
- # make sure the file has the same last modification time
- if ( my $lm = $response->last_modified ) {
- utime $lm, $lm, $file
- or warn "Cannot update modification time of '$file': $!\n";
- }
- }
- }
- # The local copy is fresh enough, so just delete the temp file
- else {
- unlink($tmpfile);
- }
- return $response;
-}
-
-
-sub _need_proxy {
- my($req, $ua) = @_;
- return if exists $req->{proxy};
- my $proxy = $ua->{proxy}{$req->uri->scheme} || return;
- if ($ua->{no_proxy}) {
- if (my $host = eval { $req->uri->host }) {
- for my $domain (@{$ua->{no_proxy}}) {
- if ($host =~ /\Q$domain\E$/) {
- return;
- }
- }
- }
- }
- $req->{proxy} = $HTTP::URI_CLASS->new($proxy);
-}
-
-
-sub proxy {
- my $self = shift;
- my $key = shift;
- if (!@_ && ref $key eq 'ARRAY') {
- die 'odd number of items in proxy arrayref!' unless @{$key} % 2 == 0;
-
- # This map reads the elements of $key 2 at a time
- return
- map { $self->proxy($key->[2 * $_], $key->[2 * $_ + 1]) }
- (0 .. @{$key} / 2 - 1);
- }
- return map { $self->proxy($_, @_) } @$key if ref $key;
-
- Carp::croak("'$key' is not a valid URI scheme") unless $key =~ /^$URI::scheme_re\z/;
- my $old = $self->{'proxy'}{$key};
- if (@_) {
- my $url = shift;
- if (defined($url) && length($url)) {
- Carp::croak("Proxy must be specified as absolute URI; '$url' is not") unless $url =~ /^$URI::scheme_re:/;
- Carp::croak("Bad http proxy specification '$url'") if $url =~ /^https?:/ && $url !~ m,^https?://[\w[],;
- }
- $self->{proxy}{$key} = $url;
- $self->set_my_handler("request_preprepare", \&_need_proxy)
- }
- return $old;
-}
-
-
-sub env_proxy {
- my ($self) = @_;
- require Encode;
- require Encode::Locale;
- my $env_request_method= $ENV{REQUEST_METHOD};
- my %seen;
- foreach my $k (sort keys %ENV) {
- my $real_key= $k;
- my $v= $ENV{$k}
- or next;
- if ( $env_request_method ) {
- # Need to be careful when called in the CGI environment, as
- # the HTTP_PROXY variable is under control of that other guy.
- next if $k =~ /^HTTP_/;
- $k = "HTTP_PROXY" if $k eq "CGI_HTTP_PROXY";
- }
- $k = lc($k);
- if (my $from_key= $seen{$k}) {
- warn "Environment contains multiple differing definitions for '$k'.\n".
- "Using value from '$from_key' ($ENV{$from_key}) and ignoring '$real_key' ($v)"
- if $v ne $ENV{$from_key};
- next;
- } else {
- $seen{$k}= $real_key;
- }
-
- next unless $k =~ /^(.*)_proxy$/;
- $k = $1;
- if ($k eq 'no') {
- $self->no_proxy(split(/\s*,\s*/, $v));
- }
- else {
- # Ignore random _proxy variables, allow only valid schemes
- next unless $k =~ /^$URI::scheme_re\z/;
- # Ignore xxx_proxy variables if xxx isn't a supported protocol
- next unless LWP::Protocol::implementor($k);
- $self->proxy($k, Encode::decode(locale => $v));
- }
- }
-}
-
-
-sub no_proxy {
- my($self, @no) = @_;
- if (@no) {
- push(@{ $self->{'no_proxy'} }, @no);
- }
- else {
- $self->{'no_proxy'} = [];
- }
-}
-
-
-sub _new_response {
- my($request, $code, $message, $content) = @_;
- $message ||= HTTP::Status::status_message($code);
- my $response = HTTP::Response->new($code, $message);
- $response->request($request);
- $response->header("Client-Date" => HTTP::Date::time2str(time));
- $response->header("Client-Warning" => "Internal response");
- $response->header("Content-Type" => "text/plain");
- $response->content($content || "$code $message\n");
- return $response;
-}
-
-
-1;
-
-__END__
-
-=pod
-
-=head1 NAME
-
-LWP::UserAgent - Web user agent class
-
-=head1 SYNOPSIS
-
- use strict;
- use warnings;
-
- use LWP::UserAgent ();
-
- my $ua = LWP::UserAgent->new(timeout => 10);
- $ua->env_proxy;
-
- my $response = $ua->get('http://example.com');
-
- if ($response->is_success) {
- print $response->decoded_content;
- }
- else {
- die $response->status_line;
- }
-
-Extra layers of security (note the C<cookie_jar> and C<protocols_allowed>):
-
- use strict;
- use warnings;
-
- use HTTP::CookieJar::LWP ();
- use LWP::UserAgent ();
-
- my $jar = HTTP::CookieJar::LWP->new;
- my $ua = LWP::UserAgent->new(
- cookie_jar => $jar,
- protocols_allowed => ['http', 'https'],
- timeout => 10,
- );
-
- $ua->env_proxy;
-
- my $response = $ua->get('http://example.com');
-
- if ($response->is_success) {
- print $response->decoded_content;
- }
- else {
- die $response->status_line;
- }
-
-=head1 DESCRIPTION
-
-The L<LWP::UserAgent> is a class implementing a web user agent.
-L<LWP::UserAgent> objects can be used to dispatch web requests.
-
-In normal use the application creates an L<LWP::UserAgent> object, and
-then configures it with values for timeouts, proxies, name, etc. It
-then creates an instance of L<HTTP::Request> for the request that
-needs to be performed. This request is then passed to one of the
-request method the UserAgent, which dispatches it using the relevant
-protocol, and returns a L<HTTP::Response> object. There are
-convenience methods for sending the most common request types:
-L<LWP::UserAgent/get>, L<LWP::UserAgent/head>, L<LWP::UserAgent/post>,
-L<LWP::UserAgent/put> and L<LWP::UserAgent/delete>. When using these
-methods, the creation of the request object is hidden as shown in the
-synopsis above.
-
-The basic approach of the library is to use HTTP-style communication
-for all protocol schemes. This means that you will construct
-L<HTTP::Request> objects and receive L<HTTP::Response> objects even
-for non-HTTP resources like I<gopher> and I<ftp>. In order to achieve
-even more similarity to HTTP-style communications, I<gopher> menus and
-file directories are converted to HTML documents.
-
-=head1 CONSTRUCTOR METHODS
-
-The following constructor methods are available:
-
-=head2 clone
-
- my $ua2 = $ua->clone;
-
-Returns a copy of the L<LWP::UserAgent> object.
-
-B<CAVEAT>: Please be aware that the clone method does not copy or clone your
-C<cookie_jar> attribute. Due to the limited restrictions on what can be used
-for your cookie jar, there is no way to clone the attribute. The C<cookie_jar>
-attribute will be C<undef> in the new object instance.
-
-=head2 new
-
- my $ua = LWP::UserAgent->new( %options )
-
-This method constructs a new L<LWP::UserAgent> object and returns it.
-Key/value pair arguments may be provided to set up the initial state.
-The following options correspond to attribute methods described below:
-
- KEY DEFAULT
- ----------- --------------------
- agent "libwww-perl/#.###"
- conn_cache undef
- cookie_jar undef
- default_headers HTTP::Headers->new
- from undef
- local_address undef
- max_redirect 7
- max_size undef
- no_proxy []
- parse_head 1
- protocols_allowed undef
- protocols_forbidden undef
- proxy undef
- requests_redirectable ['GET', 'HEAD']
- ssl_opts { verify_hostname => 1 }
- timeout 180
-
-The following additional options are also accepted: If the C<env_proxy> option
-is passed in with a true value, then proxy settings are read from environment
-variables (see L<LWP::UserAgent/env_proxy>). If C<env_proxy> isn't provided, the
-C<PERL_LWP_ENV_PROXY> environment variable controls if
-L<LWP::UserAgent/env_proxy> is called during initialization. If the
-C<keep_alive> option value is defined and non-zero, then an C<LWP::ConnCache> is set up (see
-L<LWP::UserAgent/conn_cache>). The C<keep_alive> value is passed on as the
-C<total_capacity> for the connection cache.
-
-C<proxy> must be set as an arrayref of key/value pairs. C<no_proxy> takes an
-arrayref of domains.
-
-=head1 ATTRIBUTES
-
-The settings of the configuration attributes modify the behaviour of the
-L<LWP::UserAgent> when it dispatches requests. Most of these can also
-be initialized by options passed to the constructor method.
-
-The following attribute methods are provided. The attribute value is
-left unchanged if no argument is given. The return value from each
-method is the old attribute value.
-
-=head2 agent
-
- my $agent = $ua->agent;
- $ua->agent('Checkbot/0.4 '); # append the default to the end
- $ua->agent('Mozilla/5.0');
- $ua->agent(""); # don't identify
-
-Get/set the product token that is used to identify the user agent on
-the network. The agent value is sent as the C<User-Agent> header in
-the requests.
-
-The default is a string of the form C<libwww-perl/#.###>, where C<#.###> is
-substituted with the version number of this library.
-
-If the provided string ends with space, the default C<libwww-perl/#.###>
-string is appended to it.
-
-The user agent string should be one or more simple product identifiers
-with an optional version number separated by the C</> character.
-
-=head2 conn_cache
-
- my $cache_obj = $ua->conn_cache;
- $ua->conn_cache( $cache_obj );
-
-Get/set the L<LWP::ConnCache> object to use. See L<LWP::ConnCache>
-for details.
-
-=head2 cookie_jar
-
- my $jar = $ua->cookie_jar;
- $ua->cookie_jar( $cookie_jar_obj );
-
-Get/set the cookie jar object to use. The only requirement is that
-the cookie jar object must implement the C<extract_cookies($response)> and
-C<add_cookie_header($request)> methods. These methods will then be
-invoked by the user agent as requests are sent and responses are
-received. Normally this will be a L<HTTP::Cookies> object or some
-subclass. You are, however, encouraged to use L<HTTP::CookieJar::LWP>
-instead. See L</"BEST PRACTICES"> for more information.
-
- use HTTP::CookieJar::LWP ();
-
- my $jar = HTTP::CookieJar::LWP->new;
- my $ua = LWP::UserAgent->new( cookie_jar => $jar );
-
- # or after object creation
- $ua->cookie_jar( $cookie_jar );
-
-The default is to have no cookie jar, i.e. never automatically add
-C<Cookie> headers to the requests.
-
-Shortcut: If a reference to a plain hash is passed in, it is replaced with an
-instance of L<HTTP::Cookies> that is initialized based on the hash. This form
-also automatically loads the L<HTTP::Cookies> module. It means that:
-
- $ua->cookie_jar({ file => "$ENV{HOME}/.cookies.txt" });
-
-is really just a shortcut for:
-
- require HTTP::Cookies;
- $ua->cookie_jar(HTTP::Cookies->new(file => "$ENV{HOME}/.cookies.txt"));
-
-=head2 credentials
-
- my $creds = $ua->credentials();
- $ua->credentials( $netloc, $realm );
- $ua->credentials( $netloc, $realm, $uname, $pass );
- $ua->credentials("www.example.com:80", "Some Realm", "foo", "secret");
-
-Get/set the user name and password to be used for a realm.
-
-The C<$netloc> is a string of the form C<< <host>:<port> >>. The username and
-password will only be passed to this server.
-
-=head2 default_header
-
- $ua->default_header( $field );
- $ua->default_header( $field => $value );
- $ua->default_header('Accept-Encoding' => scalar HTTP::Message::decodable());
- $ua->default_header('Accept-Language' => "no, en");
-
-This is just a shortcut for
-C<< $ua->default_headers->header( $field => $value ) >>.
-
-=head2 default_headers
-
- my $headers = $ua->default_headers;
- $ua->default_headers( $headers_obj );
-
-Get/set the headers object that will provide default header values for
-any requests sent. By default this will be an empty L<HTTP::Headers>
-object.
-
-=head2 from
-
- my $from = $ua->from;
- $ua->from('foo@bar.com');
-
-Get/set the email address for the human user who controls
-the requesting user agent. The address should be machine-usable, as
-defined in L<RFC2822|https://tools.ietf.org/html/rfc2822>. The C<from> value
-is sent as the C<From> header in the requests.
-
-The default is to not send a C<From> header. See
-L<LWP::UserAgent/default_headers> for the more general interface that allow
-any header to be defaulted.
-
-
-=head2 local_address
-
- my $address = $ua->local_address;
- $ua->local_address( $address );
-
-Get/set the local interface to bind to for network connections. The interface
-can be specified as a hostname or an IP address. This value is passed as the
-C<LocalAddr> argument to L<IO::Socket::INET>.
-
-=head2 max_redirect
-
- my $max = $ua->max_redirect;
- $ua->max_redirect( $n );
-
-This reads or sets the object's limit of how many times it will obey
-redirection responses in a given request cycle.
-
-By default, the value is C<7>. This means that if you call L<LWP::UserAgent/request>
-and the response is a redirect elsewhere which is in turn a
-redirect, and so on seven times, then LWP gives up after that seventh
-request.
-
-=head2 max_size
-
- my $size = $ua->max_size;
- $ua->max_size( $bytes );
-
-Get/set the size limit for response content. The default is C<undef>,
-which means that there is no limit. If the returned response content
-is only partial, because the size limit was exceeded, then a
-C<Client-Aborted> header will be added to the response. The content
-might end up longer than C<max_size> as we abort once appending a
-chunk of data makes the length exceed the limit. The C<Content-Length>
-header, if present, will indicate the length of the full content and
-will normally not be the same as C<< length($res->content) >>.
-
-=head2 parse_head
-
- my $bool = $ua->parse_head;
- $ua->parse_head( $boolean );
-
-Get/set a value indicating whether we should initialize response
-headers from the E<lt>head> section of HTML documents. The default is
-true. I<Do not turn this off> unless you know what you are doing.
-
-=head2 protocols_allowed
-
- my $aref = $ua->protocols_allowed; # get allowed protocols
- $ua->protocols_allowed( \@protocols ); # allow ONLY these
- $ua->protocols_allowed(undef); # delete the list
- $ua->protocols_allowed(['http',]); # ONLY allow http
-
-By default, an object has neither a C<protocols_allowed> list, nor a
-L<LWP::UserAgent/protocols_forbidden> list.
-
-This reads (or sets) this user agent's list of protocols that the
-request methods will exclusively allow. The protocol names are case
-insensitive.
-
-For example: C<< $ua->protocols_allowed( [ 'http', 'https'] ); >>
-means that this user agent will I<allow only> those protocols,
-and attempts to use this user agent to access URLs with any other
-schemes (like C<ftp://...>) will result in a 500 error.
-
-Note that having a C<protocols_allowed> list causes any
-L<LWP::UserAgent/protocols_forbidden> list to be ignored.
-
-=head2 protocols_forbidden
-
- my $aref = $ua->protocols_forbidden; # get the forbidden list
- $ua->protocols_forbidden(\@protocols); # do not allow these
- $ua->protocols_forbidden(['http',]); # All http reqs get a 500
- $ua->protocols_forbidden(undef); # delete the list
-
-This reads (or sets) this user agent's list of protocols that the
-request method will I<not> allow. The protocol names are case
-insensitive.
-
-For example: C<< $ua->protocols_forbidden( [ 'file', 'mailto'] ); >>
-means that this user agent will I<not> allow those protocols, and
-attempts to use this user agent to access URLs with those schemes
-will result in a 500 error.
-
-=head2 requests_redirectable
-
- my $aref = $ua->requests_redirectable;
- $ua->requests_redirectable( \@requests );
- $ua->requests_redirectable(['GET', 'HEAD',]); # the default
-
-This reads or sets the object's list of request names that
-L<LWP::UserAgent/redirect_ok> will allow redirection for. By default, this
-is C<['GET', 'HEAD']>, as per L<RFC 2616|https://tools.ietf.org/html/rfc2616>.
-To change to include C<POST>, consider:
-
- push @{ $ua->requests_redirectable }, 'POST';
-
-=head2 send_te
-
- my $bool = $ua->send_te;
- $ua->send_te( $boolean );
-
-If true, will send a C<TE> header along with the request. The default is
-true. Set it to false to disable the C<TE> header for systems who can't
-handle it.
-
-=head2 show_progress
-
- my $bool = $ua->show_progress;
- $ua->show_progress( $boolean );
-
-Get/set a value indicating whether a progress bar should be displayed
-on the terminal as requests are processed. The default is false.
-
-=head2 ssl_opts
-
- my @keys = $ua->ssl_opts;
- my $val = $ua->ssl_opts( $key );
- $ua->ssl_opts( $key => $value );
-
-Get/set the options for SSL connections. Without argument return the list
-of options keys currently set. With a single argument return the current
-value for the given option. With 2 arguments set the option value and return
-the old. Setting an option to the value C<undef> removes this option.
-
-The options that LWP relates to are:
-
-=over
-
-=item C<verify_hostname> => $bool
-
-When TRUE LWP will for secure protocol schemes ensure it connects to servers
-that have a valid certificate matching the expected hostname. If FALSE no
-checks are made and you can't be sure that you communicate with the expected peer.
-The no checks behaviour was the default for libwww-perl-5.837 and earlier releases.
-
-This option is initialized from the C<PERL_LWP_SSL_VERIFY_HOSTNAME> environment
-variable. If this environment variable isn't set; then C<verify_hostname>
-defaults to 1.
-
-=item C<SSL_ca_file> => $path
-
-The path to a file containing Certificate Authority certificates.
-A default setting for this option is provided by checking the environment
-variables C<PERL_LWP_SSL_CA_FILE> and C<HTTPS_CA_FILE> in order.
-
-=item C<SSL_ca_path> => $path
-
-The path to a directory containing files containing Certificate Authority
-certificates.
-A default setting for this option is provided by checking the environment
-variables C<PERL_LWP_SSL_CA_PATH> and C<HTTPS_CA_DIR> in order.
-
-=back
-
-Other options can be set and are processed directly by the SSL Socket implementation
-in use. See L<IO::Socket::SSL> or L<Net::SSL> for details.
-
-The libwww-perl core no longer bundles protocol plugins for SSL. You will need
-to install L<LWP::Protocol::https> separately to enable support for processing
-https-URLs.
-
-=head2 timeout
-
- my $secs = $ua->timeout;
- $ua->timeout( $secs );
-
-Get/set the timeout value in seconds. The default value is
-180 seconds, i.e. 3 minutes.
-
-The request is aborted if no activity on the connection to the server
-is observed for C<timeout> seconds. This means that the time it takes
-for the complete transaction and the L<LWP::UserAgent/request> method to
-actually return might be longer.
-
-When a request times out, a response object is still returned. The response
-will have a standard HTTP Status Code (500). This response will have the
-"Client-Warning" header set to the value of "Internal response". See the
-L<LWP::UserAgent/get> method description below for further details.
-
-=head1 PROXY ATTRIBUTES
-
-The following methods set up when requests should be passed via a
-proxy server.
-
-=head2 env_proxy
-
- $ua->env_proxy;
-
-Load proxy settings from C<*_proxy> environment variables. You might
-specify proxies like this (sh-syntax):
-
- gopher_proxy=http://proxy.my.place/
- wais_proxy=http://proxy.my.place/
- no_proxy="localhost,example.com"
- export gopher_proxy wais_proxy no_proxy
-
-csh or tcsh users should use the C<setenv> command to define these
-environment variables.
-
-On systems with case insensitive environment variables there exists a
-name clash between the CGI environment variables and the C<HTTP_PROXY>
-environment variable normally picked up by C<env_proxy>. Because of
-this C<HTTP_PROXY> is not honored for CGI scripts. The
-C<CGI_HTTP_PROXY> environment variable can be used instead.
-
-=head2 no_proxy
-
- $ua->no_proxy( @domains );
- $ua->no_proxy('localhost', 'example.com');
- $ua->no_proxy(); # clear the list
-
-Do not proxy requests to the given domains. Calling C<no_proxy> without
-any domains clears the list of domains.
-
-=head2 proxy
-
- $ua->proxy(\@schemes, $proxy_url)
- $ua->proxy(['http', 'ftp'], 'http://proxy.sn.no:8001/');
-
- # For a single scheme:
- $ua->proxy($scheme, $proxy_url)
- $ua->proxy('gopher', 'http://proxy.sn.no:8001/');
-
- # To set multiple proxies at once:
- $ua->proxy([
- ftp => 'http://ftp.example.com:8001/',
- [ 'http', 'https' ] => 'http://http.example.com:8001/',
- ]);
-
-Set/retrieve proxy URL for a scheme.
-
-The first form specifies that the URL is to be used as a proxy for
-access methods listed in the list in the first method argument,
-i.e. C<http> and C<ftp>.
-
-The second form shows a shorthand form for specifying
-proxy URL for a single access scheme.
-
-The third form demonstrates setting multiple proxies at once. This is also
-the only form accepted by the constructor.
-
-=head1 HANDLERS
-
-Handlers are code that injected at various phases during the
-processing of requests. The following methods are provided to manage
-the active handlers:
-
-=head2 add_handler
-
- $ua->add_handler( $phase => \&cb, %matchspec )
-
-Add handler to be invoked in the given processing phase. For how to
-specify C<%matchspec> see L<HTTP::Config/"Matching">.
-
-The possible values C<$phase> and the corresponding callback signatures are as
-follows. Note that the handlers are documented in the order in which they will
-be run, which is:
-
- request_preprepare
- request_prepare
- request_send
- response_header
- response_data
- response_done
- response_redirect
-
-=over
-
-=item request_preprepare => sub { my($request, $ua, $handler) = @_; ... }
-
-The handler is called before the C<request_prepare> and other standard
-initialization of the request. This can be used to set up headers
-and attributes that the C<request_prepare> handler depends on. Proxy
-initialization should take place here; but in general don't register
-handlers for this phase.
-
-=item request_prepare => sub { my($request, $ua, $handler) = @_; ... }
-
-The handler is called before the request is sent and can modify the
-request any way it see fit. This can for instance be used to add
-certain headers to specific requests.
-
-The method can assign a new request object to C<$_[0]> to replace the
-request that is sent fully.
-
-The return value from the callback is ignored. If an exception is
-raised it will abort the request and make the request method return a
-"400 Bad request" response.
-
-=item request_send => sub { my($request, $ua, $handler) = @_; ... }
-
-This handler gets a chance of handling requests before they're sent to the
-protocol handlers. It should return an L<HTTP::Response> object if it
-wishes to terminate the processing; otherwise it should return nothing.
-
-The C<response_header> and C<response_data> handlers will not be
-invoked for this response, but the C<response_done> will be.
-
-=item response_header => sub { my($response, $ua, $handler) = @_; ... }
-
-This handler is called right after the response headers have been
-received, but before any content data. The handler might set up
-handlers for data and might croak to abort the request.
-
-The handler might set the C<< $response->{default_add_content} >> value to
-control if any received data should be added to the response object
-directly. This will initially be false if the C<< $ua->request() >> method
-was called with a C<$content_file> or C<$content_cb argument>; otherwise true.
-
-=item response_data => sub { my($response, $ua, $handler, $data) = @_; ... }
-
-This handler is called for each chunk of data received for the
-response. The handler might croak to abort the request.
-
-This handler needs to return a TRUE value to be called again for
-subsequent chunks for the same request.
-
-=item response_done => sub { my($response, $ua, $handler) = @_; ... }
-
-The handler is called after the response has been fully received, but
-before any redirect handling is attempted. The handler can be used to
-extract information or modify the response.
-
-=item response_redirect => sub { my($response, $ua, $handler) = @_; ... }
-
-The handler is called in C<< $ua->request >> after C<response_done>. If the
-handler returns an L<HTTP::Request> object we'll start over with processing
-this request instead.
-
-=back
-
-For all of these, C<$handler> is a code reference to the handler that
-is currently being run.
-
-=head2 get_my_handler
-
- $ua->get_my_handler( $phase, %matchspec );
- $ua->get_my_handler( $phase, %matchspec, $init );
-
-Will retrieve the matching handler as hash ref.
-
-If C<$init> is passed as a true value, create and add the
-handler if it's not found. If C<$init> is a subroutine reference, then
-it's called with the created handler hash as argument. This sub might
-populate the hash with extra fields; especially the callback. If
-C<$init> is a hash reference, merge the hashes.
-
-=head2 handlers
-
- $ua->handlers( $phase, $request )
- $ua->handlers( $phase, $response )
-
-Returns the handlers that apply to the given request or response at
-the given processing phase.
-
-=head2 remove_handler
-
- $ua->remove_handler( undef, %matchspec );
- $ua->remove_handler( $phase, %matchspec );
- $ua->remove_handler(); # REMOVE ALL HANDLERS IN ALL PHASES
-
-Remove handlers that match the given C<%matchspec>. If C<$phase> is not
-provided, remove handlers from all phases.
-
-Be careful as calling this function with C<%matchspec> that is not
-specific enough can remove handlers not owned by you. It's probably
-better to use the L<LWP::UserAgent/set_my_handler> method instead.
-
-The removed handlers are returned.
-
-=head2 set_my_handler
-
- $ua->set_my_handler( $phase, $cb, %matchspec );
- $ua->set_my_handler($phase, undef); # remove handler for phase
-
-Set handlers private to the executing subroutine. Works by defaulting
-an C<owner> field to the C<%matchspec> that holds the name of the called
-subroutine. You might pass an explicit C<owner> to override this.
-
-If C<$cb> is passed as C<undef>, remove the handler.
-
-=head1 REQUEST METHODS
-
-The methods described in this section are used to dispatch requests
-via the user agent. The following request methods are provided:
-
-=head2 delete
-
- my $res = $ua->delete( $url );
- my $res = $ua->delete( $url, $field_name => $value, ... );
-
-This method will dispatch a C<DELETE> request on the given URL. Additional
-headers and content options are the same as for the L<LWP::UserAgent/get>
-method.
-
-This method will use the C<DELETE()> function from L<HTTP::Request::Common>
-to build the request. See L<HTTP::Request::Common> for a details on
-how to pass form content and other advanced features.
-
-=head2 get
-
- my $res = $ua->get( $url );
- my $res = $ua->get( $url , $field_name => $value, ... );
-
-This method will dispatch a C<GET> request on the given URL. Further
-arguments can be given to initialize the headers of the request. These
-are given as separate name/value pairs. The return value is a
-response object. See L<HTTP::Response> for a description of the
-interface it provides.
-
-There will still be a response object returned when LWP can't connect to the
-server specified in the URL or when other failures in protocol handlers occur.
-These internal responses use the standard HTTP status codes, so the responses
-can't be differentiated by testing the response status code alone. Error
-responses that LWP generates internally will have the "Client-Warning" header
-set to the value "Internal response". If you need to differentiate these
-internal responses from responses that a remote server actually generates, you
-need to test this header value.
-
-Fields names that start with ":" are special. These will not
-initialize headers of the request but will determine how the response
-content is treated. The following special field names are recognized:
-
- ':content_file' => $filename
- ':content_cb' => \&callback
- ':read_size_hint' => $bytes
-
-If a C<$filename> is provided with the C<:content_file> option, then the
-response content will be saved here instead of in the response
-object. If a callback is provided with the C<:content_cb> option then
-this function will be called for each chunk of the response content as
-it is received from the server. If neither of these options are
-given, then the response content will accumulate in the response
-object itself. This might not be suitable for very large response
-bodies. Only one of C<:content_file> or C<:content_cb> can be
-specified. The content of unsuccessful responses will always
-accumulate in the response object itself, regardless of the
-C<:content_file> or C<:content_cb> options passed in. Note that errors
-writing to the content file (for example due to permission denied
-or the filesystem being full) will be reported via the C<Client-Aborted>
-or C<X-Died> response headers, and not the C<is_success> method.
-
-The C<:read_size_hint> option is passed to the protocol module which
-will try to read data from the server in chunks of this size. A
-smaller value for the C<:read_size_hint> will result in a higher
-number of callback invocations.
-
-The callback function is called with 3 arguments: a chunk of data, a
-reference to the response object, and a reference to the protocol
-object. The callback can abort the request by invoking C<die()>. The
-exception message will show up as the "X-Died" header field in the
-response returned by the C<< $ua->get() >> method.
-
-=head2 head
-
- my $res = $ua->head( $url );
- my $res = $ua->head( $url , $field_name => $value, ... );
-
-This method will dispatch a C<HEAD> request on the given URL.
-Otherwise it works like the L<LWP::UserAgent/get> method described above.
-
-=head2 is_protocol_supported
-
- my $bool = $ua->is_protocol_supported( $scheme );
-
-You can use this method to test whether this user agent object supports the
-specified C<scheme>. (The C<scheme> might be a string (like C<http> or
-C<ftp>) or it might be an L<URI> object reference.)
-
-Whether a scheme is supported is determined by the user agent's
-C<protocols_allowed> or C<protocols_forbidden> lists (if any), and by
-the capabilities of LWP. I.e., this will return true only if LWP
-supports this protocol I<and> it's permitted for this particular
-object.
-
-=head2 is_online
-
- my $bool = $ua->is_online;
-
-Tries to determine if you have access to the Internet. Returns C<1> (true)
-if the built-in heuristics determine that the user agent is
-able to access the Internet (over HTTP) or C<0> (false).
-
-See also L<LWP::Online>.
-
-=head2 mirror
-
- my $res = $ua->mirror( $url, $filename );
-
-This method will get the document identified by URL and store it in
-file called C<$filename>. If the file already exists, then the request
-will contain an C<If-Modified-Since> header matching the modification
-time of the file. If the document on the server has not changed since
-this time, then nothing happens. If the document has been updated, it
-will be downloaded again. The modification time of the file will be
-forced to match that of the server.
-
-Uses L<File::Copy/move> to attempt to atomically replace the C<$filename>.
-
-The return value is an L<HTTP::Response> object.
-
-=head2 patch
-
- # Any version of HTTP::Message works with this form:
- my $res = $ua->patch( $url, $field_name => $value, Content => $content );
-
- # Using hash or array references requires HTTP::Message >= 6.12
- use HTTP::Request 6.12;
- my $res = $ua->patch( $url, \%form );
- my $res = $ua->patch( $url, \@form );
- my $res = $ua->patch( $url, \%form, $field_name => $value, ... );
- my $res = $ua->patch( $url, $field_name => $value, Content => \%form );
- my $res = $ua->patch( $url, $field_name => $value, Content => \@form );
-
-This method will dispatch a C<PATCH> request on the given URL, with
-C<%form> or C<@form> providing the key/value pairs for the fill-in form
-content. Additional headers and content options are the same as for
-the L<LWP::UserAgent/get> method.
-
-CAVEAT:
-
-This method can only accept content that is in key-value pairs when using
-L<HTTP::Request::Common> prior to version C<6.12>. Any use of hash or array
-references will result in an error prior to version C<6.12>.
-
-This method will use the C<PATCH> function from L<HTTP::Request::Common>
-to build the request. See L<HTTP::Request::Common> for a details on
-how to pass form content and other advanced features.
-
-=head2 post
-
- my $res = $ua->post( $url, \%form );
- my $res = $ua->post( $url, \@form );
- my $res = $ua->post( $url, \%form, $field_name => $value, ... );
- my $res = $ua->post( $url, $field_name => $value, Content => \%form );
- my $res = $ua->post( $url, $field_name => $value, Content => \@form );
- my $res = $ua->post( $url, $field_name => $value, Content => $content );
-
-This method will dispatch a C<POST> request on the given URL, with
-C<%form> or C<@form> providing the key/value pairs for the fill-in form
-content. Additional headers and content options are the same as for
-the L<LWP::UserAgent/get> method.
-
-This method will use the C<POST> function from L<HTTP::Request::Common>
-to build the request. See L<HTTP::Request::Common> for a details on
-how to pass form content and other advanced features.
-
-=head2 put
-
- # Any version of HTTP::Message works with this form:
- my $res = $ua->put( $url, $field_name => $value, Content => $content );
-
- # Using hash or array references requires HTTP::Message >= 6.07
- use HTTP::Request 6.07;
- my $res = $ua->put( $url, \%form );
- my $res = $ua->put( $url, \@form );
- my $res = $ua->put( $url, \%form, $field_name => $value, ... );
- my $res = $ua->put( $url, $field_name => $value, Content => \%form );
- my $res = $ua->put( $url, $field_name => $value, Content => \@form );
-
-This method will dispatch a C<PUT> request on the given URL, with
-C<%form> or C<@form> providing the key/value pairs for the fill-in form
-content. Additional headers and content options are the same as for
-the L<LWP::UserAgent/get> method.
-
-CAVEAT:
-
-This method can only accept content that is in key-value pairs when using
-L<HTTP::Request::Common> prior to version C<6.07>. Any use of hash or array
-references will result in an error prior to version C<6.07>.
-
-This method will use the C<PUT> function from L<HTTP::Request::Common>
-to build the request. See L<HTTP::Request::Common> for a details on
-how to pass form content and other advanced features.
-
-=head2 request
-
- my $res = $ua->request( $request );
- my $res = $ua->request( $request, $content_file );
- my $res = $ua->request( $request, $content_cb );
- my $res = $ua->request( $request, $content_cb, $read_size_hint );
-
-This method will dispatch the given C<$request> object. Normally this
-will be an instance of the L<HTTP::Request> class, but any object with
-a similar interface will do. The return value is an L<HTTP::Response> object.
-
-The C<request> method will process redirects and authentication
-responses transparently. This means that it may actually send several
-simple requests via the L<LWP::UserAgent/simple_request> method described below.
-
-The request methods described above; L<LWP::UserAgent/get>, L<LWP::UserAgent/head>,
-L<LWP::UserAgent/post> and L<LWP::UserAgent/mirror> will all dispatch the request
-they build via this method. They are convenience methods that simply hide the
-creation of the request object for you.
-
-The C<$content_file>, C<$content_cb> and C<$read_size_hint> all correspond to
-options described with the L<LWP::UserAgent/get> method above. Note that errors
-writing to the content file (for example due to permission denied
-or the filesystem being full) will be reported via the C<Client-Aborted>
-or C<X-Died> response headers, and not the C<is_success> method.
-
-You are allowed to use a CODE reference as C<content> in the request
-object passed in. The C<content> function should return the content
-when called. The content can be returned in chunks. The content
-function will be invoked repeatedly until it return an empty string to
-signal that there is no more content.
-
-=head2 simple_request
-
- my $request = HTTP::Request->new( ... );
- my $res = $ua->simple_request( $request );
- my $res = $ua->simple_request( $request, $content_file );
- my $res = $ua->simple_request( $request, $content_cb );
- my $res = $ua->simple_request( $request, $content_cb, $read_size_hint );
-
-This method dispatches a single request and returns the response
-received. Arguments are the same as for the L<LWP::UserAgent/request> described above.
-
-The difference from L<LWP::UserAgent/request> is that C<simple_request> will not try to
-handle redirects or authentication responses. The L<LWP::UserAgent/request> method
-will, in fact, invoke this method for each simple request it sends.
-
-=head1 CALLBACK METHODS
-
-The following methods will be invoked as requests are processed. These
-methods are documented here because subclasses of L<LWP::UserAgent>
-might want to override their behaviour.
-
-=head2 get_basic_credentials
-
- # This checks wantarray and can either return an array:
- my ($user, $pass) = $ua->get_basic_credentials( $realm, $uri, $isproxy );
- # or a string that looks like "user:pass"
- my $creds = $ua->get_basic_credentials($realm, $uri, $isproxy);
-
-This is called by L<LWP::UserAgent/request> to retrieve credentials for documents
-protected by Basic or Digest Authentication. The arguments passed in
-is the C<$realm> provided by the server, the C<$uri> requested and a
-C<boolean flag> to indicate if this is authentication against a proxy server.
-
-The method should return a username and password. It should return an
-empty list to abort the authentication resolution attempt. Subclasses
-can override this method to prompt the user for the information. An
-example of this can be found in C<lwp-request> program distributed
-with this library.
-
-The base implementation simply checks a set of pre-stored member
-variables, set up with the L<LWP::UserAgent/credentials> method.
-
-=head2 prepare_request
-
- $request = $ua->prepare_request( $request );
-
-This method is invoked by L<LWP::UserAgent/simple_request>. Its task is
-to modify the given C<$request> object by setting up various headers based
-on the attributes of the user agent. The return value should normally be the
-C<$request> object passed in. If a different request object is returned
-it will be the one actually processed.
-
-The headers affected by the base implementation are; C<User-Agent>,
-C<From>, C<Range> and C<Cookie>.
-
-=head2 progress
-
- my $prog = $ua->progress( $status, $request_or_response );
-
-This is called frequently as the response is received regardless of
-how the content is processed. The method is called with C<$status>
-"begin" at the start of processing the request and with C<$state> "end"
-before the request method returns. In between these C<$status> will be
-the fraction of the response currently received or the string "tick"
-if the fraction can't be calculated.
-
-When C<$status> is "begin" the second argument is the L<HTTP::Request> object,
-otherwise it is the L<HTTP::Response> object.
-
-=head2 redirect_ok
-
- my $bool = $ua->redirect_ok( $prospective_request, $response );
-
-This method is called by L<LWP::UserAgent/request> before it tries to follow a
-redirection to the request in C<$response>. This should return a true
-value if this redirection is permissible. The C<$prospective_request>
-will be the request to be sent if this method returns true.
-
-The base implementation will return false unless the method
-is in the object's C<requests_redirectable> list,
-false if the proposed redirection is to a C<file://...>
-URL, and true otherwise.
-
-=head1 BEST PRACTICES
-
-The default settings can get you up and running quickly, but there are settings
-you can change in order to make your life easier.
-
-=head2 Handling Cookies
-
-You are encouraged to install L<Mozilla::PublicSuffix> and use
-L<HTTP::CookieJar::LWP> as your cookie jar. L<HTTP::CookieJar::LWP> provides a
-better security model matching that of current Web browsers when
-L<Mozilla::PublicSuffix> is installed.
-
- use HTTP::CookieJar::LWP ();
-
- my $jar = HTTP::CookieJar::LWP->new;
- my $ua = LWP::UserAgent->new( cookie_jar => $jar );
-
-See L</"cookie_jar"> for more information.
-
-=head2 Managing Protocols
-
-C<protocols_allowed> gives you the ability to allow arbitrary protocols.
-
- my $ua = LWP::UserAgent->new(
- protocols_allowed => [ 'http', 'https' ]
- );
-
-This will prevent you from inadvertently following URLs like
-C<file:///etc/passwd>. See L</"protocols_allowed">.
-
-C<protocols_forbidden> gives you the ability to deny arbitrary protocols.
-
- my $ua = LWP::UserAgent->new(
- protocols_forbidden => [ 'file', 'mailto', 'ssh', ]
- );
-
-This can also prevent you from inadvertently following URLs like
-C<file:///etc/passwd>. See L</protocols_forbidden>.
-
-=head1 SEE ALSO
-
-See L<LWP> for a complete overview of libwww-perl5. See L<lwpcook>
-and the scripts F<lwp-request> and F<lwp-download> for examples of
-usage.
-
-See L<HTTP::Request> and L<HTTP::Response> for a description of the
-message objects dispatched and received. See L<HTTP::Request::Common>
-and L<HTML::Form> for other ways to build request objects.
-
-See L<WWW::Mechanize> and L<WWW::Search> for examples of more
-specialized user agents based on L<LWP::UserAgent>.
-
-=head1 COPYRIGHT AND LICENSE
-
-Copyright 1995-2009 Gisle Aas.
-
-This library is free software; you can redistribute it and/or
-modify it under the same terms as Perl itself.
-
-=cut