home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / perl_ste.zip / LWP / Simple.pm < prev    next >
Text File  |  1997-11-20  |  8KB  |  327 lines
  1. #
  2. # $Id: Simple.pm,v 1.25 1997/11/21 00:29:41 aas Exp $
  3.  
  4. =head1 NAME
  5.  
  6. get, head, getprint, getstore, mirror - Procedural LWP interface
  7.  
  8. =head1 SYNOPSIS
  9.  
  10.  perl -MLWP::Simple -e 'getprint "http://www.sn.no"'
  11.  
  12.  use LWP::Simple;
  13.  $content = get("http://www.sn.no/")
  14.  if (mirror("http://www.sn.no/", "foo") == RC_NOT_MODIFIED) {
  15.      ...
  16.  }
  17.  
  18.  if (is_success(getprint("http://www.sn.no/"))) {
  19.      ...
  20.  }
  21.  
  22. =head1 DESCRIPTION
  23.  
  24. This interface is intended for those who want a simplified view of the
  25. libwww-perl library.  It should also be suitable for one-liners.  If
  26. you need more control or access to the header fields in the requests
  27. sent and responses received you should use the full object oriented
  28. interface provided by the C<LWP::UserAgent> module.
  29.  
  30. The following functions are provided (and exported) by this module:
  31.  
  32. =over 3
  33.  
  34. =item get($url)
  35.  
  36. The get() function will fetch the document identified by the given URL
  37. and return it.  It returns C<undef> if it fails.  The $url argument can
  38. be either a simple string or a reference to a URI::URL object.
  39.  
  40. You will not be able to examine the response code or response headers
  41. (like 'Content-Type') when you are accessing the web using this
  42. function.  If you need this information you should use the full OO
  43. interface (see L<LWP::UserAgent>).
  44.  
  45. =item head($url)
  46.  
  47. Get document headers. Returns the following 5 values if successful:
  48. ($content_type, $document_length, $modified_time, $expires, $server)
  49.  
  50. Returns an empty list if it fails.  In scalar context returns TRUE if
  51. successful.
  52.  
  53. =item getprint($url)
  54.  
  55. Get and print a document identified by a URL. The document is printed
  56. on STDOUT as data is received from the network.  If the request fails,
  57. then the status code and message is printed on STDERR.  The return
  58. value is the HTTP response code.
  59.  
  60. =item getstore($url, $file)
  61.  
  62. Gets a document identified by a URL and stores it in the file. The
  63. return value is the HTTP response code.
  64.  
  65. =item mirror($url, $file)
  66.  
  67. Get and store a document identified by a URL, using
  68. I<If-modified-since>, and checking of the I<Content-Length>.  Returns
  69. the HTTP response code.
  70.  
  71. =back
  72.  
  73. This module also exports the HTTP::Status constants and procedures.
  74. These can be used when you check the response code from getprint(),
  75. getstore() and mirror().  The constants are:
  76.  
  77.    RC_CONTINUE
  78.    RC_SWITCHING_PROTOCOLS
  79.    RC_OK
  80.    RC_CREATED
  81.    RC_ACCEPTED
  82.    RC_NON_AUTHORITATIVE_INFORMATION
  83.    RC_NO_CONTENT
  84.    RC_RESET_CONTENT
  85.    RC_PARTIAL_CONTENT
  86.    RC_MULTIPLE_CHOICES
  87.    RC_MOVED_PERMANENTLY
  88.    RC_MOVED_TEMPORARILY
  89.    RC_SEE_OTHER
  90.    RC_NOT_MODIFIED
  91.    RC_USE_PROXY
  92.    RC_BAD_REQUEST
  93.    RC_UNAUTHORIZED
  94.    RC_PAYMENT_REQUIRED
  95.    RC_FORBIDDEN
  96.    RC_NOT_FOUND
  97.    RC_METHOD_NOT_ALLOWED
  98.    RC_NOT_ACCEPTABLE
  99.    RC_PROXY_AUTHENTICATION_REQUIRED
  100.    RC_REQUEST_TIMEOUT
  101.    RC_CONFLICT
  102.    RC_GONE
  103.    RC_LENGTH_REQUIRED
  104.    RC_PRECONDITION_FAILED
  105.    RC_REQUEST_ENTITY_TOO_LARGE
  106.    RC_REQUEST_URI_TOO_LARGE
  107.    RC_UNSUPPORTED_MEDIA_TYPE
  108.    RC_INTERNAL_SERVER_ERROR
  109.    RC_NOT_IMPLEMENTED
  110.    RC_BAD_GATEWAY
  111.    RC_SERVICE_UNAVAILABLE
  112.    RC_GATEWAY_TIMEOUT
  113.    RC_HTTP_VERSION_NOT_SUPPORTED
  114.  
  115. The HTTP::Status classification functions are:
  116.  
  117. =over 3
  118.  
  119. =item is_success($rc)
  120.  
  121. Check if response code indicated successfull request.
  122.  
  123. =item is_error($rc)
  124.  
  125. Check if response code indicated that an error occured.
  126.  
  127. =back
  128.  
  129. The module will also export the LWP::UserAgent object as C<$ua> if you
  130. ask for it explicitly.
  131.  
  132. The user agent created by this module will identify itself as
  133. "LWP::Simple/#.##" (where "#.##" is the libwww-perl version number)
  134. and will initialize its proxy defaults from the environment (by
  135. calling $ua->env_proxy).
  136.  
  137. =head1 SEE ALSO
  138.  
  139. L<LWP>, L<LWP::UserAgent>, L<HTTP::Status>, L<lwp-request>,
  140. L<lwp-mirror>
  141.  
  142. =cut
  143.  
  144.  
  145. package LWP::Simple;
  146.  
  147. use strict;
  148. use vars qw($ua %loop_check $FULL_LWP @EXPORT @EXPORT_OK $VERSION);
  149.  
  150. require Exporter;
  151.  
  152. @EXPORT = qw(get head getprint getstore mirror);
  153. @EXPORT_OK = qw($ua);
  154.  
  155. # I really hate this.  I was a bad idea to do it in the first place.
  156. # Wonder how to get rid of it???  (It even makes LWP::Simple 7% slower
  157. # for trivial tests)
  158. use HTTP::Status;
  159. push(@EXPORT, @HTTP::Status::EXPORT);
  160.  
  161.  
  162. $VERSION = sprintf("%d.%02d", q$Revision: 1.25 $ =~ /(\d+)\.(\d+)/);
  163. $FULL_LWP++ if grep {$_ eq "http_proxy"} keys %ENV;
  164.  
  165.  
  166. sub import
  167. {
  168.     my $pkg = shift;
  169.     my $callpkg = caller;
  170.     $FULL_LWP++ if grep $_ eq '$ua', @_;
  171.     Exporter::export($pkg, $callpkg, @_);
  172. }
  173.  
  174.  
  175. sub _init_ua
  176. {
  177.     require LWP;
  178.     require LWP::UserAgent;
  179.     require HTTP::Status;
  180.     require HTTP::Date;
  181.     $ua = new LWP::UserAgent;  # we create a global UserAgent object
  182.     my $ver = $LWP::VERSION = $LWP::VERSION;  # avoid warning
  183.     $ua->agent("LWP::Simple/$LWP::VERSION");
  184.     $ua->env_proxy;
  185. }
  186.  
  187.  
  188. sub get ($)
  189. {
  190.     %loop_check = ();
  191.     goto \&_get;
  192. }
  193.  
  194.  
  195. sub get_old ($)
  196. {
  197.     my($url) = @_;
  198.     _init_ua() unless $ua;
  199.  
  200.     my $request = HTTP::Request->new(GET => $url);
  201.     my $response = $ua->request($request);
  202.  
  203.     return $response->content if $response->is_success;
  204.     return undef;
  205. }
  206.  
  207.  
  208. sub head ($)
  209. {
  210.     my($url) = @_;
  211.     _init_ua() unless $ua;
  212.  
  213.     my $request = HTTP::Request->new(HEAD => $url);
  214.     my $response = $ua->request($request);
  215.  
  216.     if ($response->is_success) {
  217.     return $response unless wantarray;
  218.     return ($response->header('Content-Type'),
  219.         $response->header('Content-Length'),
  220.         HTTP::Date::str2time($response->header('Last-Modified')),
  221.         HTTP::Date::str2time($response->header('Expires')),
  222.         $response->header('Server'),
  223.            );
  224.     }
  225.     return;
  226. }
  227.  
  228.  
  229. sub getprint ($)
  230. {
  231.     my($url) = @_;
  232.     _init_ua() unless $ua;
  233.  
  234.     my $request = HTTP::Request->new(GET => $url);
  235.     local($\) = ""; # ensure standard $OUTPUT_RECORD_SEPARATOR
  236.     my $response = $ua->request($request, sub { print $_[0] });
  237.     unless ($response->is_success) {
  238.     print STDERR $response->status_line, " <URL:$url>\n";
  239.     }
  240.     $response->code;
  241. }
  242.  
  243.  
  244. sub getstore ($$)
  245. {
  246.     my($url, $file) = @_;
  247.     _init_ua() unless $ua;
  248.  
  249.     my $request = HTTP::Request->new(GET => $url);
  250.     my $response = $ua->request($request, $file);
  251.  
  252.     $response->code;
  253. }
  254.  
  255.  
  256. sub mirror ($$)
  257. {
  258.     my($url, $file) = @_;
  259.     _init_ua() unless $ua;
  260.     my $response = $ua->mirror($url, $file);
  261.     $response->code;
  262. }
  263.  
  264.  
  265. sub _get
  266. {
  267.     my $url = shift;
  268.     my $ret;
  269.     if (!$FULL_LWP && $url =~ m,^http://([^/:]+)(?::(\d+))?(/\S*)?$,) {
  270.     my $host = $1;
  271.     my $port = $2 || 80;
  272.     my $path = $3;
  273.     $path = "/" unless defined($path);
  274.     return _trivial_http_get($host, $port, $path);
  275.     } else {
  276.         _init_ua() unless $ua;
  277.     my $request = HTTP::Request->new(GET => $url);
  278.     my $response = $ua->request($request);
  279.     return $response->is_success ? $response->content : undef;
  280.     }
  281. }
  282.  
  283.  
  284. sub _trivial_http_get
  285. {
  286.    my($host, $port, $path) = @_;
  287.    #print "HOST=$host, PORT=$port, PATH=$path\n";
  288.  
  289.    require IO::Socket;
  290.    local($^W) = 0;
  291.    my $sock = IO::Socket::INET->new(PeerAddr => $host,
  292.                                     PeerPort => $port,
  293.                                     Proto    => 'tcp',
  294.                                     Timeout  => 60) || return;
  295.    $sock->autoflush;
  296.    my $netloc = $host;
  297.    $netloc .= ":$port" if $port != 80;
  298.    print $sock join("\015\012" =>
  299.                     "GET $path HTTP/1.0",
  300.                     "Host: $netloc",
  301.                     "User-Agent: lwp-trivial/$VERSION",
  302.                     "", "");
  303.  
  304.    my $buf = "";
  305.    my $n;
  306.    1 while $n = sysread($sock, $buf, 8*1024, length($buf));
  307.    return undef unless defined($n);
  308.  
  309.    if ($buf =~ m,^HTTP/\d+\.\d+\s+(\d+)[^\012]*\012,) {
  310.        my $code = $1;
  311.        #print "CODE=$code\n";
  312.        if ($code =~ /^3/ && $buf =~ /\012Location:\s*(\S+)/) {
  313.            # redirect
  314.            my $url = $1;
  315.            return undef if $loop_check{$url}++;
  316.            return _get($url);
  317.        }
  318.        return undef unless $code =~ /^2/;
  319.        $buf =~ s/.+?\015?\012\015?\012//s;  # zap header
  320.    }
  321.  
  322.    return $buf;
  323. }
  324.  
  325.  
  326. 1;
  327.