|
Chapter 17 The LWP Library |
|
The HTTP modules implement an interface to the HTTP messaging protocol used in web transactions. Its most useful modules are HTTP::Request and HTTP::Response, which create objects for client requests and server responses. Other modules provide means for manipulating headers, interpreting server response codes, managing cookies, converting date formats, and creating basic server applications.
Client applications created with LWP::UserAgent use HTTP::Request objects to create and send requests to servers. The information returned from a server is saved as an HTTP::Response object. Both of these objects are subclasses of HTTP::Message, which provides general methods of creating and modifying HTTP messages. The header information included in HTTP messages can be represented by objects of the HTTP::Headers class.
HTTP::Status includes functions to classify response codes into the categories of informational, successful, redirection, error, client error, or server error. It also exports symbolic aliases of HTTP response codes; one could refer to the status code of 200 as RC_OK and refer to 404 as RC_NOT_FOUND.
The HTTP::Date module converts date strings from and to machine time. The HTTP::Daemon module can be used to create webserver applications, utilizing the functionality of the rest of the LWP modules to communicate with clients.
This module summarizes a web client's request. For a simple GET request, you define an object with the GET method and assign a URL to apply it to. Basic headers would be filled in automatically by LWP. For a POST or PUT request, you might want to specify a custom HTTP::Headers object for the request, or use the contents of a file for an entity body. Since HTTP::Request inherits everything in HTTP::Message, you can use the header and entity body manipulation methods from HTTP::Message in HTTP::Request objects.
The constructor for HTTP::Request looks like this:
The method and URL values for the request are required parameters. The header and content arguments are not required, nor even necessary for all requests. The parameters are described as follows:$req = http::Request->new ( method , url , [ $header , [ content ]]);
method
A string specifying the HTTP request method. GET, HEAD, and POST are the most commonly used. Other methods defined in the HTTP specification such as PUT and DELETE are not supported by most servers.
url
The address and resource name of the information you are requesting. This argument may be either a string containing an absolute URL (the hostname is required), or a URI::URL object that stores all the information about the URL.
$header
A reference to an HTTP::Headers object.
content
A scalar that specifies the entity body of the request. If omitted, the entity body is empty.
The following methods can be used on HTTP::Request objects:
Responses from a web server are described by HTTP::Response objects. An HTTP response message contains a status line, headers, and any content data that was requested by the client (like an HTML file). The status line is the minimum requirement for a response. It contains the version of HTTP that the server is running, a status code indicating the success, failure, or other condition the request received from the server, and a short message describing the status code.
If LWP has problems fulfilling your request, it internally generates an HTTP::Response object and fills in an appropriate response code. In the context of web client programming, you'll usually get an HTTP::Response object from LWP::UserAgent and LWP::RobotUA.
If you plan to write extensions to LWP or to a web server or proxy server, you might use HTTP::Response to generate your own responses.
The constructor for HTTP::Response looks like this:
In its simplest form, an HTTP::Response object can contain just a response code. If you would like to specify a more detailed message than "OK" or "Not found," you can specify a text description of the response code as the second parameter. As a third parameter, you can pass a reference to an HTTP::Headers object to specify the response headers. Finally, you can also include an entity body in the fourth parameter as a scalar.$resp = HTTP::Response->new ( rc , [ msg , [ header , [ content ]]]);
For client applications, it is unlikely that you will build your own response object with the constructor for this class. You receive a client object when you use the
request
method on an LWP::UserAgent object, for example:
The server's response is contained in the object$ua = LWP::UserAgent->new; $req = HTTP::Request->new(GET, $url) $resp = $ua->request($req);
$resp
. When you have this object, you can use the HTTP::Response methods to get the information about the response. Since HTTP::Response is a subclass of HTTP::Message, you can also use methods from that class on response objects. See
Section 17.3.8, "HTTP::Message
" later in this chapter for a description of its methods.
The following methods can be used on objects created by HTTP::Response:
This module deals with HTTP header definition and manipulation. You can use these methods on HTTP::Request and HTTP::Response objects to retrieve headers they contain, or to set new headers and values for new objects you are building.
The constructor for an HTTP::Headers object looks like this:
This code creates a new headers object. You can set headers in the constructor by providing a header name and its value. Multiple$h = HTTP::Headers->new([ name => val ],...);
name
=>
val
pairs can be used to set multiple headers.
The following methods can be used by objects in the HTTP::Headers class. These methods can also be used on objects from HTTP::Request and HTTP::Response, since they inherit from HTTP::Headers. In fact, most header manipulation will occur on the request and response objects in LWP applications.
The HTTP::Headers class allows you to use a number of convenience methods on header objects to set (or read) common field values. If you supply a value for an argument, that value will be set for the field. The previous value for the header is always returned. The following methods are available:
date expires if_modified_since if_unmodified_since last_modified content_type content_encoding content_length content_language title user_agent server from referrer www_authenticate proxy_authenticate authorization proxy_authorization authorization_basic proxy_authorization_basic
This module provides methods to determine the type of a response code. It also exports a list of mnemonics that can be used by the programmer to refer to a status code.
The following methods are used on response objects:
is_info
is_success
is_redirect
is_client_error
is_server_error
is_error
Returns true when the response code is 400 through 599. When an error occurs, you might want to use
error_as_HTML
to generate an HTML explanation of the error.
HTTP::Status exports the following constant functions for you to use as mnemonic substitutes for status codes. For example, you could do something like:
if ($rc = RC_OK) {....}
Here are the mnemonics, followed by the status codes they represent: RC_CONTINUE (100) RC_SWITCHING_PROTOCOLS (101) RC_OK (200) RC_CREATED (201) RC_ACCEPTED (202) RC_NON_AUTHORITATIVE_INFORMATION (203) RC_NO_CONTENT (204) RC_RESET_CONTENT (205) RC_PARTIAL_CONTENT (206) RC_MULTIPLE_CHOICES (300) RC_MOVED_PERMANENTLY (301) RC_MOVED_TEMPORARILY (302) RC_SEE_OTHER (303) RC_NOT_MODIFIED (304) RC_USE_PROXY (305) RC_BAD_REQUEST (400) RC_UNAUTHORIZED (401) RC_PAYMENT_REQUIRED (402) RC_FORBIDDEN (403) RC_NOT_FOUND (404) RC_METHOD_NOT_ALLOWED (405) RC_NOT_ACCEPTABLE (406) RC_PROXY_AUTHENTICATION_REQUIRED (407) RC_REQUEST_TIMEOUT (408) RC_CONFLICT (409) RC_GONE (410) RC_LENGTH_REQUIRED (411) RC_PRECONDITION_FAILED (412) RC_REQUEST_ENTITY_TOO_LARGE (413) RC_REQUEST_URI_TOO_LARGE (414) RC_UNSUPPORTED_MEDIA_TYPE (415) RC_REQUEST_RANGE_NOT_SATISFIABLE (416) RC_INTERNAL_SERVER_ERROR (500) RC_NOT_IMPLEMENTED (501) RC_BAD_GATEWAY (502) RC_SERVICE_UNAVAILABLE (503) RC_GATEWAY_TIMEOUT (504) RC_HTTP_VERSION_NOT_SUPPORTED (505)
The HTTP::Date module is useful when you want to process a date string. It exports two functions that convert date strings to and from standard time formats:
HTTP cookies provide a mechanism for preserving information about a client or user across several different visits to a site or page. The "cookie" is a name-value pair sent to the client on its initial visit to a page. This cookie is stored by the client and sent back in the request upon revisit to the same page.
A server initializes a cookie with the Set-Cookie header. Set-Cookie sets the name and value of a cookie, as well as other parameters such as how long the cookie is valid and the range of URLs to which the cookie applies. Each cookie (a single name-value pair) is sent in its own Set-Cookie header, so if there is more than one cookie being sent to a client, multiple Set-Cookie headers are sent in the response. Two Set-Cookie headers may be used in server responses: Set-Cookie is defined in the original Netscape cookie specification, and Set-Cookie2 is the latest, IETF-defined header. Both header styles are supported by HTTP::Cookies. The latest browsers also support both styles.
If a client visits a page for which it has a valid cookie stored, the client sends the cookie in the request with the Cookie header. This header's value contains any name-value pairs that apply to the URL. Multiple cookies are separated by semicolons in the header.
The HTTP::Cookies module is used to retrieve, return, and manage the cookies used by an LWP::UserAgent client application. Setting cookies from LWP-created server requires only the coding of the proper response headers sent by an HTTP::Daemon server application. HTTP::Cookies is not designed to be used in setting cookies on the server side, although you may find use for it in managing sent cookies.
The
new
constructor for HTTP::Cookies creates an object called a cookie jar, which represents a collection of saved cookies usually read from a file. Methods on the cookie jar object allow you to add new cookies or to send cookie information in a client request to a specific URL. The constructor may take optional parameters, as shown in the following example:
The cookie jar object$cjar = HTTP::Cookies->new( file => 'cookies.txt', autosave => 1, ignore_discard => 0 );
$cjar
created here contains any cookie information stored in the file
cookies.txt
. The
autosave
parameter takes a boolean value which determines if the state of the cookie jar is saved to the file upon destruction of the object.
ignore_discard
also takes a boolean value to determine if cookies marked to be discarded are still saved to the file.
Cookies received by a client are added to the cookie jar with the
extract_cookies
method. This method searches an HTTP::Response object for Set-Cookie and Set-Cookie2 headers and adds them to the cookie jar. Cookies are sent in a client request using the
add-cookie-header
method. This method takes an HTTP::Request object with the URL component already set, and if the URL matches any entries in the cookie jar, adds the appropriate Cookie headers to the request.
These methods can be used on a cookie jar object created by HTTP::Cookies:
The HTTP::Cookies class contains one subclass that supports Netscape-style cookies within a cookie jar object. Netscape-style cookies were defined in the original cookie specification for Navigator 1.1, which outlined the syntax for the Cookie and Set-Cookie HTTP headers. Netscape cookie headers are different from the newer Set-Cookie2-style cookies in that they don't support as many additional parameters when a cookie is set. The Cookie header also does not use a version-number attribute. Many browsers and servers still use the original Netscape cookies, and the Netscape subclass of HTTP::Cookies can be used to support this style.
The
new
constructor for this subclass creates a Netscape-compatible cookie jar object like this:
$njar = HTTP::Cookies::Netscape->new( File => "$ENV{HOME}/.netscape/cookies", AutoSave => 1 );
The methods described above can be used on this object, although many of the parameters used in Set-Cookie2 headers will simply be lost when cookies are saved to the cookie jar.
The HTTP::Daemon module creates HTTP server applications. The module provides objects based on the IO::Socket::INET class that can listen on a socket for client requests and send server responses. The objects implemented by the module are HTTP 1.1 servers. Client requests are stored as HTTP::Request objects, and all the methods for that class can be used to obtain information about the request. HTTP::Response objects can be used to send information back to the client.
An HTTP::Daemon object is created by using the
new
constructor. Since the base class for this object is IO::Socket::INET, the parameters used in that class's constructor are the same here. For example:
The HTTP::Daemon object is a server socket that automatically listens for requests on the specified port (or on the default port if none is given). When a client request is received, the object uses the$d = HTTP::Daemon->new ( LocalAddr => 'maude.oreilly.com', LocalPort => 8888, Listen => 5 );
accept
method to create a connection with the client on the network.
$d = HTTP::Daemon->new; while ( $c = $d->accept ) { $req = $c->get_request; # process request and send response here } $c = undef; # don't forget to close the socket
The
accept
method returns a reference to a new object of the HTTP::Daemon::ClientConn class. This class is also based on IO::Socket::INET and is used to extract the request message and send the response and any requested file content.
The sockets created by both HTTP::Daemon and HTTP::Daemon::ClientConn work the same way as those in IO::Socket::INET. The methods are also the same except for some slight variations in usage. The methods for the HTTP::Daemon classes are listed in the sections below and include the adjusted IO::Socket::INET methods. For more detailed information about sockets and the IO::Socket classes and methods, see Chapter 13 .
The following methods can be used on HTTP::Daemon objects:
The following methods can be used on HTTP::Daemon::ClientConn objects:
HTTP::Message is the generic base-class for HTTP::Request and HTTP::Response. It provides a couple of methods that are used on both classes. The constructor for this class is used internally by the Request and Response classes, so you will probably not need to use it. Methods defined by the HTTP::Headers class will also work on Message objects.
|
|
|
|
| 17.2 The LWP Modules |
|
17.4 The HTML Module |