You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@labs.apache.org by fi...@apache.org on 2007/11/13 05:55:36 UTC

svn commit: r594435 [6/26] - /labs/webarch/trunk/http/draft-fielding-http/orig/

Added: labs/webarch/trunk/http/draft-fielding-http/orig/draft-fielding-http-p1-messaging-orig.xml
URL: http://svn.apache.org/viewvc/labs/webarch/trunk/http/draft-fielding-http/orig/draft-fielding-http-p1-messaging-orig.xml?rev=594435&view=auto
==============================================================================
--- labs/webarch/trunk/http/draft-fielding-http/orig/draft-fielding-http-p1-messaging-orig.xml (added)
+++ labs/webarch/trunk/http/draft-fielding-http/orig/draft-fielding-http-p1-messaging-orig.xml Mon Nov 12 20:55:34 2007
@@ -0,0 +1,4079 @@
+<?xml version="1.0" encoding="utf-8"?>
+<?xml-stylesheet type='text/xsl' href='rfc2629.xslt' ?>
+<!DOCTYPE rfc [
+  <!ENTITY MAY "<bcp14 xmlns='http://purl.org/net/xml2rfc/ext'>MAY</bcp14>">
+  <!ENTITY MUST "<bcp14 xmlns='http://purl.org/net/xml2rfc/ext'>MUST</bcp14>">
+  <!ENTITY MUST-NOT "<bcp14 xmlns='http://purl.org/net/xml2rfc/ext'>MUST NOT</bcp14>">
+  <!ENTITY OPTIONAL "<bcp14 xmlns='http://purl.org/net/xml2rfc/ext'>OPTIONAL</bcp14>">
+  <!ENTITY RECOMMENDED "<bcp14 xmlns='http://purl.org/net/xml2rfc/ext'>RECOMMENDED</bcp14>">
+  <!ENTITY REQUIRED "<bcp14 xmlns='http://purl.org/net/xml2rfc/ext'>REQUIRED</bcp14>">
+  <!ENTITY SHALL "<bcp14 xmlns='http://purl.org/net/xml2rfc/ext'>SHALL</bcp14>">
+  <!ENTITY SHALL-NOT "<bcp14 xmlns='http://purl.org/net/xml2rfc/ext'>SHALL NOT</bcp14>">
+  <!ENTITY SHOULD "<bcp14 xmlns='http://purl.org/net/xml2rfc/ext'>SHOULD</bcp14>">
+  <!ENTITY SHOULD-NOT "<bcp14 xmlns='http://purl.org/net/xml2rfc/ext'>SHOULD NOT</bcp14>">
+  <!ENTITY caching                "[Part 6]">
+  <!ENTITY payload                "[Part 3]">
+  <!ENTITY CONNECT                "[Part 2]">
+  <!ENTITY content.negotiation    "[Part 3]">
+  <!ENTITY diff2045entity         "[Part 3]">
+  <!ENTITY entity                 "[Part 3]">
+  <!ENTITY entity-header-fields   "[Part 3]">
+  <!ENTITY header-cache-control   "[Part 6]">
+  <!ENTITY header-expect          "[Part 2]">
+  <!ENTITY header-pragma          "[Part 6]">
+  <!ENTITY header-warning         "[Part 6]">
+  <!ENTITY idempotent-methods     "[Part 2]">
+  <!ENTITY qvalue                 "[Part 3]">
+  <!ENTITY request-header-fields  "[Part 2]">
+  <!ENTITY response-header-fields "[Part 2]">
+  <!ENTITY method                 "[Part 2]">
+  <!ENTITY status-codes           "[Part 2]">
+  <!ENTITY status-100             "[Part 2]">
+  <!ENTITY status-1xx             "[Part 2]">
+  <!ENTITY status-414             "[Part 2]">
+]>
+<?rfc toc="yes" ?>
+<?rfc symrefs="yes" ?>
+<?rfc sortrefs="yes" ?>
+<?rfc compact="yes"?>
+<?rfc subcompact="no" ?>
+<?rfc linkmailto="no" ?>
+<?rfc editing="no" ?>
+<?rfc-ext allow-markup-in-artwork="yes" ?>
+<?rfc-ext include-references-in-index="yes" ?>
+<rfc obsoletes="2068, 2616, 2617" category="std"
+     ipr="full3978" docName="draft-fielding-http-p1-messaging-00"
+     xmlns:x='http://purl.org/net/xml2rfc/ext' xmlns:ed="http://greenbytes.de/2002/rfcedit">
+<front>
+
+  <title abbrev="HTTP/1.1">HTTP/1.1, part 1: URIs, Connections, and Message Framing</title>
+
+  <author initials="R." surname="Fielding" fullname="Roy T. Fielding">
+    <organization abbrev="UC Irvine">Department of Information and Computer Science</organization>
+    <address>
+      <postal>
+        <street>University of California, Irvine</street>
+        <city>Irvine</city>
+        <region>CA</region>
+        <code>92697-3425</code>
+      </postal>
+      <facsimile>+1(949)824-1715</facsimile>
+      <email>fielding@ics.uci.edu</email>
+    </address>
+  </author>
+
+  <author initials="J." surname="Gettys" fullname="James Gettys">
+    <organization abbrev="Compaq/W3C">World Wide Web Consortium</organization>
+    <address>
+      <postal>
+        <street>MIT Laboratory for Computer Science, NE43-356</street>
+        <street>545 Technology Square</street>
+        <city>Cambridge</city>
+        <region>MA</region>
+        <code>02139</code>
+      </postal>
+      <facsimile>+1(617)258-8682</facsimile>
+      <email>jg@w3.org</email>
+    </address>
+  </author>
+  
+  <author initials="J." surname="Mogul" fullname="Jeffrey C. Mogul">
+    <organization abbrev="Compaq">Compaq Computer Corporation</organization>
+    <address>
+      <postal>
+        <street>Western Research Laboratory</street>
+        <street>250 University Avenue</street>
+        <city>Palo Alto</city>
+        <region>CA</region>
+        <code>94305</code>
+      </postal>
+      <email>mogul@wrl.dec.com</email>
+    </address>
+  </author>
+
+  <author initials="H." surname="Frystyk" fullname="Henrik Frystyk Nielsen">
+    <organization abbrev="W3C/MIT">World Wide Web Consortium</organization>
+    <address>
+      <postal>
+        <street>MIT Laboratory for Computer Science, NE43-356</street>
+        <street>545 Technology Square</street>
+        <city>Cambridge</city>
+        <region>MA</region>
+        <code>02139</code>
+      </postal>
+      <facsimile>+1(617)258-8682</facsimile>
+      <email>frystyk@w3.org</email>
+    </address>
+  </author>
+
+  <author initials="L." surname="Masinter" fullname="Larry Masinter">
+    <organization abbrev="Xerox">Xerox Corporation</organization>
+    <address>
+      <postal>
+        <street>MIT Laboratory for Computer Science, NE43-356</street>
+        <street>3333 Coyote Hill Road</street>
+        <city>Palo Alto</city>
+        <region>CA</region>
+        <code>94034</code>
+      </postal>
+      <email>masinter@parc.xerox.com</email>
+    </address>
+  </author>
+  
+  <author initials="P." surname="Leach" fullname="Paul J. Leach">
+    <organization abbrev="Microsoft">Microsoft Corporation</organization>
+    <address>
+      <postal>
+        <street>1 Microsoft Way</street>
+        <city>Redmond</city>
+        <region>WA</region>
+        <code>98052</code>
+      </postal>
+      <email>paulle@microsoft.com</email>
+    </address>
+  </author>
+   
+  <author initials="T." surname="Berners-Lee" fullname="Tim Berners-Lee">
+    <organization abbrev="W3C/MIT">World Wide Web Consortium</organization>
+    <address>
+      <postal>
+        <street>MIT Laboratory for Computer Science, NE43-356</street>
+        <street>545 Technology Square</street>
+        <city>Cambridge</city>
+        <region>MA</region>
+        <code>02139</code>
+      </postal>
+      <facsimile>+1(617)258-8682</facsimile>
+      <email>timbl@w3.org</email>
+    </address>
+  </author>
+
+  <date month="September" year="2007"/>
+
+<abstract>
+<t>
+   The Hypertext Transfer Protocol (HTTP) is an application-level
+   protocol for distributed, collaborative, hypermedia information
+   systems. HTTP has been in use by the World Wide Web global information
+   initiative since 1990. This document is Part 1 of the eight-part specification
+   that defines the protocol referred to as "HTTP/1.1" and, taken together,
+   updates RFC 2616 and RFC 2617.  Part 1 provides an overview of HTTP and
+   its associated terminology, defines the "http" and "https" Uniform
+   Resource Identifier (URI) schemes, defines the generic message syntax
+   and parsing requirements for HTTP message frames, and describes
+   general security concerns for implementations.
+</t>
+</abstract>
+</front>
+<middle>
+<section title="Introduction" anchor="introduction">
+<t>
+   This document will define aspects of HTTP related to overall network
+   operation, message framing, interaction with transport protocols, and
+   URI schemes. Right now it only includes the extracted relevant sections
+   of <xref target="RFC2616"/> and <xref target="RFC2617"/>.
+</t>
+<section title="Purpose" anchor="intro.purpose">
+<t>
+   The Hypertext Transfer Protocol (HTTP) is an application-level
+   protocol for distributed, collaborative, hypermedia information
+   systems. HTTP has been in use by the World-Wide Web global
+   information initiative since 1990. The first version of HTTP,
+   referred to as HTTP/0.9, was a simple protocol for raw data transfer
+   across the Internet. HTTP/1.0, as defined by RFC 1945 <xref target="RFC1945"/>, improved
+   the protocol by allowing messages to be in the format of MIME-like
+   messages, containing metainformation about the data transferred and
+   modifiers on the request/response semantics. However, HTTP/1.0 does
+   not sufficiently take into consideration the effects of hierarchical
+   proxies, caching, the need for persistent connections, or virtual
+   hosts. In addition, the proliferation of incompletely-implemented
+   applications calling themselves "HTTP/1.0" has necessitated a
+   protocol version change in order for two communicating applications
+   to determine each other's true capabilities.
+</t>
+<t>
+   This specification defines the protocol referred to as "HTTP/1.1".
+   This protocol includes more stringent requirements than HTTP/1.0 in
+   order to ensure reliable implementation of its features.
+</t>
+<t>
+   Practical information systems require more functionality than simple
+   retrieval, including search, front-end update, and annotation. HTTP
+   allows an open-ended set of methods and headers that indicate the
+   purpose of a request <xref target="RFC2324"/>. It builds on the discipline of reference
+   provided by the Uniform Resource Identifier (URI) <xref target="RFC1630"/>, as a location
+   (URL) <xref target="RFC1738"/> or name (URN) <xref target="RFC1737"/>, for indicating the resource to which a
+   method is to be applied. Messages are passed in a format similar to
+   that used by Internet mail <xref target="RFC822"/> as defined by the Multipurpose
+   Internet Mail Extensions (MIME) <xref target="RFC2045"/>.
+</t>
+<t>
+   HTTP is also used as a generic protocol for communication between
+   user agents and proxies/gateways to other Internet systems, including
+   those supported by the SMTP <xref target="RFC821"/>, NNTP <xref target="RFC977"/>, FTP <xref target="RFC959"/>, Gopher <xref target="RFC1436"/>,
+   and WAIS <xref target="WAIS"/> protocols. In this way, HTTP allows basic hypermedia
+   access to resources available from diverse applications.
+</t>
+</section>
+
+<section title="Requirements" anchor="intro.requirements">
+<t>
+   The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
+   "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this
+   document are to be interpreted as described in RFC 2119 <xref target="RFC2119"/>.
+</t>
+<t>
+   An implementation is not compliant if it fails to satisfy one or more
+   of the &MUST; or &REQUIRED; level requirements for the protocols it
+   implements. An implementation that satisfies all the &MUST; or &REQUIRED;
+   level and all the &SHOULD; level requirements for its protocols is said
+   to be "unconditionally compliant"; one that satisfies all the &MUST;
+   level requirements but not all the &SHOULD; level requirements for its
+   protocols is said to be "conditionally compliant."
+</t>
+</section>
+
+<section title="Terminology" anchor="intro.terminology">
+<t>
+   This specification uses a number of terms to refer to the roles
+   played by participants in, and objects of, the HTTP communication.
+</t>
+<t>
+  <iref item="connection"/>
+  <x:dfn>connection</x:dfn>
+  <list>
+    <t>
+      A transport layer virtual circuit established between two programs
+      for the purpose of communication.
+    </t>
+  </list>
+</t>
+<t>
+  <iref item="message"/>
+  <x:dfn>message</x:dfn>
+  <list>
+    <t>
+      The basic unit of HTTP communication, consisting of a structured
+      sequence of octets matching the syntax defined in <xref target="http.message"/> and
+      transmitted via the connection.
+    </t>
+  </list>
+</t>
+<t>
+  <iref item="request"/>
+  <x:dfn>request</x:dfn>
+  <list>
+    <t>
+      An HTTP request message, as defined in <xref target="request"/>.
+    </t>
+  </list>
+</t>
+<t>
+  <iref item="response"/>
+  <x:dfn>response</x:dfn>
+  <list>
+    <t>
+      An HTTP response message, as defined in <xref target="response"/>.
+    </t>
+  </list>
+</t>
+<t>
+  <iref item="resource"/>
+  <x:dfn>resource</x:dfn>
+  <list>
+    <t>
+      A network data object or service that can be identified by a URI,
+      as defined in <xref target="uri"/>. Resources may be available in multiple
+      representations (e.g. multiple languages, data formats, size, and
+      resolutions) or vary in other ways.
+    </t>
+  </list>
+</t>
+<t>
+  <iref item="entity"/>
+  <x:dfn>entity</x:dfn>
+  <list>
+    <t>
+      The information transferred as the payload of a request or
+      response. An entity consists of metainformation in the form of
+      entity-header fields and content in the form of an entity-body, as
+      described in &entity;.
+    </t>
+  </list>
+</t>
+<t>
+  <iref item="representation"/>
+  <x:dfn>representation</x:dfn>
+  <list>
+    <t>
+      An entity included with a response that is subject to content
+      negotiation, as described in &content.negotiation;. There may exist multiple
+      representations associated with a particular response status.
+    </t>
+  </list>
+</t>
+<t>
+  <iref item="content negotiation"/>
+  <x:dfn>content negotiation</x:dfn>
+  <list>
+    <t>
+      The mechanism for selecting the appropriate representation when
+      servicing a request, as described in &content.negotiation;. The
+      representation of entities in any response can be negotiated
+      (including error responses).
+    </t>
+  </list>
+</t>
+<t>
+  <iref item="variant"/>
+  <x:dfn>variant</x:dfn>
+  <list>
+    <t>
+      A resource may have one, or more than one, representation(s)
+      associated with it at any given instant. Each of these
+      representations is termed a `varriant'.  Use of the term `variant'
+      does not necessarily imply that the resource is subject to content
+      negotiation.
+    </t>
+  </list>
+</t>
+<t>
+  <iref item="client"/>
+  <x:dfn>client</x:dfn>
+  <list>
+    <t>
+      A program that establishes connections for the purpose of sending
+      requests.
+    </t>
+  </list>
+</t>
+<t>
+  <iref item="user agent"/>
+  <x:dfn>user agent</x:dfn>
+  <list>
+    <t>
+      The client which initiates a request. These are often browsers,
+      editors, spiders (web-traversing robots), or other end user tools.
+    </t>
+  </list>
+</t>
+<t>
+  <iref item="server"/>
+  <x:dfn>server</x:dfn>
+  <list>
+    <t>
+      An application program that accepts connections in order to
+      service requests by sending back responses. Any given program may
+      be capable of being both a client and a server; our use of these
+      terms refers only to the role being performed by the program for a
+      particular connection, rather than to the program's capabilities
+      in general. Likewise, any server may act as an origin server,
+      proxy, gateway, or tunnel, switching behavior based on the nature
+      of each request.
+    </t>
+  </list>
+</t>
+<t>
+  <iref item="origin server"/>
+  <x:dfn>origin server</x:dfn>
+  <list>
+    <t>
+      The server on which a given resource resides or is to be created.
+    </t>
+  </list>
+</t>
+<t>
+  <iref item="proxy"/>
+  <x:dfn>proxy</x:dfn>
+  <list>
+    <t>
+      An intermediary program which acts as both a server and a client
+      for the purpose of making requests on behalf of other clients.
+      Requests are serviced internally or by passing them on, with
+      possible translation, to other servers. A proxy &MUST; implement
+      both the client and server requirements of this specification. A
+      "transparent proxy" is a proxy that does not modify the request or
+      response beyond what is required for proxy authentication and
+      identification. A "non-transparent proxy" is a proxy that modifies
+      the request or response in order to provide some added service to
+      the user agent, such as group annotation services, media type
+      transformation, protocol reduction, or anonymity filtering. Except
+      where either transparent or non-transparent behavior is explicitly
+      stated, the HTTP proxy requirements apply to both types of
+      proxies.
+    </t>
+  </list>
+</t>
+<t>
+  <iref item="gateway"/>
+  <x:dfn>gateway</x:dfn>
+  <list>
+    <t>
+      A server which acts as an intermediary for some other server.
+      Unlike a proxy, a gateway receives requests as if it were the
+      origin server for the requested resource; the requesting client
+      may not be aware that it is communicating with a gateway.
+    </t>
+  </list>
+</t>
+<t>
+  <iref item="tunnel"/>
+  <x:dfn>tunnel</x:dfn>
+  <list>
+    <t>
+      An intermediary program which is acting as a blind relay between
+      two connections. Once active, a tunnel is not considered a party
+      to the HTTP communication, though the tunnel may have been
+      initiated by an HTTP request. The tunnel ceases to exist when both
+      ends of the relayed connections are closed.
+    </t>
+  </list>
+</t>
+<t>
+  <iref item="cache"/>
+  <x:dfn>cache</x:dfn>
+  <list>
+    <t>
+      A program's local store of response messages and the subsystem
+      that controls its message storage, retrieval, and deletion. A
+      cache stores cacheable responses in order to reduce the response
+      time and network bandwidth consumption on future, equivalent
+      requests. Any client or server may include a cache, though a cache
+      cannot be used by a server that is acting as a tunnel.
+    </t>
+  </list>
+</t>
+<t>
+  <iref item="cacheable"/>
+  <x:dfn>cacheable</x:dfn>
+  <list>
+    <t>
+      A response is cacheable if a cache is allowed to store a copy of
+      the response message for use in answering subsequent requests. The
+      rules for determining the cacheability of HTTP responses are
+      defined in &caching;. Even if a resource is cacheable, there may
+      be additional constraints on whether a cache can use the cached
+      copy for a particular request.
+    </t>
+  </list>
+</t>
+<t>
+  <iref item="upstream"/>
+  <iref item="downstream"/>
+  <x:dfn>upstream</x:dfn>/<x:dfn>downstream</x:dfn>
+  <list>
+    <t>
+      Upstream and downstream describe the flow of a message: all
+      messages flow from upstream to downstream.
+    </t>
+  </list>
+</t>
+<t>
+  <iref item="inbound"/>
+  <iref item="outbound"/>
+  <x:dfn>inbound</x:dfn>/<x:dfn>outbound</x:dfn>
+  <list>
+    <t>
+      Inbound and outbound refer to the request and response paths for
+      messages: "inbound" means "traveling toward the origin server",
+      and "outbound" means "traveling toward the user agent"
+    </t>
+  </list>
+</t>
+</section>
+
+<section title="Overall Operation" anchor="intro.overall.operation">
+<t>
+   The HTTP protocol is a request/response protocol. A client sends a
+   request to the server in the form of a request method, URI, and
+   protocol version, followed by a MIME-like message containing request
+   modifiers, client information, and possible body content over a
+   connection with a server. The server responds with a status line,
+   including the message's protocol version and a success or error code,
+   followed by a MIME-like message containing server information, entity
+   metainformation, and possible entity-body content. The relationship
+   between HTTP and MIME is described in &diff2045entity;.
+</t>
+<t>
+   Most HTTP communication is initiated by a user agent and consists of
+   a request to be applied to a resource on some origin server. In the
+   simplest case, this may be accomplished via a single connection (v)
+   between the user agent (UA) and the origin server (O).
+</t>
+<figure><artwork type="drawing">
+       request chain ------------------------&gt;
+    UA -------------------v------------------- O
+       &lt;----------------------- response chain
+</artwork></figure>
+<t>
+   A more complicated situation occurs when one or more intermediaries
+   are present in the request/response chain. There are three common
+   forms of intermediary: proxy, gateway, and tunnel. A proxy is a
+   forwarding agent, receiving requests for a URI in its absolute form,
+   rewriting all or part of the message, and forwarding the reformatted
+   request toward the server identified by the URI. A gateway is a
+   receiving agent, acting as a layer above some other server(s) and, if
+   necessary, translating the requests to the underlying server's
+   protocol. A tunnel acts as a relay point between two connections
+   without changing the messages; tunnels are used when the
+   communication needs to pass through an intermediary (such as a
+   firewall) even when the intermediary cannot understand the contents
+   of the messages.
+</t>
+<figure><artwork type="drawing">
+       request chain --------------------------------------&gt;
+    UA -----v----- A -----v----- B -----v----- C -----v----- O
+       &lt;------------------------------------- response chain
+</artwork></figure>
+<t>
+   The figure above shows three intermediaries (A, B, and C) between the
+   user agent and origin server. A request or response message that
+   travels the whole chain will pass through four separate connections.
+   This distinction is important because some HTTP communication options
+   may apply only to the connection with the nearest, non-tunnel
+   neighbor, only to the end-points of the chain, or to all connections
+   along the chain. Although the diagram is linear, each participant may
+   be engaged in multiple, simultaneous communications. For example, B
+   may be receiving requests from many clients other than A, and/or
+   forwarding requests to servers other than C, at the same time that it
+   is handling A's request.
+</t>
+<t>
+   Any party to the communication which is not acting as a tunnel may
+   employ an internal cache for handling requests. The effect of a cache
+   is that the request/response chain is shortened if one of the
+   participants along the chain has a cached response applicable to that
+   request. The following illustrates the resulting chain if B has a
+   cached copy of an earlier response from O (via C) for a request which
+   has not been cached by UA or A.
+</t>
+<figure><artwork type="drawing">
+          request chain ----------&gt;
+       UA -----v----- A -----v----- B - - - - - - C - - - - - - O
+          &lt;--------- response chain
+</artwork></figure>
+<t>
+   Not all responses are usefully cacheable, and some requests may
+   contain modifiers which place special requirements on cache behavior.
+   HTTP requirements for cache behavior and cacheable responses are
+   defined in &caching;.
+</t>
+<t>
+   In fact, there are a wide variety of architectures and configurations
+   of caches and proxies currently being experimented with or deployed
+   across the World Wide Web. These systems include national hierarchies
+   of proxy caches to save transoceanic bandwidth, systems that
+   broadcast or multicast cache entries, organizations that distribute
+   subsets of cached data via CD-ROM, and so on. HTTP systems are used
+   in corporate intranets over high-bandwidth links, and for access via
+   PDAs with low-power radio links and intermittent connectivity. The
+   goal of HTTP/1.1 is to support the wide diversity of configurations
+   already deployed while introducing protocol constructs that meet the
+   needs of those who build web applications that require high
+   reliability and, failing that, at least reliable indications of
+   failure.
+</t>
+<t>
+   HTTP communication usually takes place over TCP/IP connections. The
+   default port is TCP 80 <xref target="RFC1700"/>, but other ports can be used. This does
+   not preclude HTTP from being implemented on top of any other protocol
+   on the Internet, or on other networks. HTTP only presumes a reliable
+   transport; any protocol that provides such guarantees can be used;
+   the mapping of the HTTP/1.1 request and response structures onto the
+   transport data units of the protocol in question is outside the scope
+   of this specification.
+</t>
+<t>
+   In HTTP/1.0, most implementations used a new connection for each
+   request/response exchange. In HTTP/1.1, a connection may be used for
+   one or more request/response exchanges, although connections may be
+   closed for a variety of reasons (see <xref target="persistent.connections"/>).
+</t>
+</section>
+</section>
+
+<section title="Notational Conventions and Generic Grammar" anchor="notation">
+
+<section title="Augmented BNF" anchor="notation.abnf">
+<t>
+   All of the mechanisms specified in this document are described in
+   both prose and an augmented Backus-Naur Form (BNF) similar to that
+   used by RFC 822 <xref target="RFC822"/>. Implementors will need to be familiar with the
+   notation in order to understand this specification. The augmented BNF
+   includes the following constructs:
+</t>
+<t>
+   name = definition
+  <list>
+    <t>
+      The name of a rule is simply the name itself (without any
+      enclosing "&lt;" and "&gt;") and is separated from its definition by the
+      equal "=" character. White space is only significant in that
+      indentation of continuation lines is used to indicate a rule
+      definition that spans more than one line. Certain basic rules are
+      in uppercase, such as SP, LWS, HT, CRLF, DIGIT, ALPHA, etc. Angle
+      brackets are used within definitions whenever their presence will
+      facilitate discerning the use of rule names.
+    </t>
+  </list>
+</t>
+<t>
+   "literal"
+  <list>
+    <t>
+      Quotation marks surround literal text. Unless stated otherwise,
+      the text is case-insensitive.
+    </t>
+  </list>
+</t>
+<t>
+   rule1 | rule2
+  <list>
+    <t>
+      Elements separated by a bar ("|") are alternatives, e.g., "yes |
+      no" will accept yes or no.
+    </t>
+  </list>
+</t>
+<t>
+   (rule1 rule2)
+  <list>
+    <t>
+      Elements enclosed in parentheses are treated as a single element.
+      Thus, "(elem (foo | bar) elem)" allows the token sequences "elem
+      foo elem" and "elem bar elem".
+    </t>
+  </list>
+</t>
+<t>
+   *rule
+  <list>
+    <t>
+      The character "*" preceding an element indicates repetition. The
+      full form is "&lt;n&gt;*&lt;m&gt;element" indicating at least &lt;n&gt; and at most
+      &lt;m&gt; occurrences of element. Default values are 0 and infinity so
+      that "*(element)" allows any number, including zero; "1*element"
+      requires at least one; and "1*2element" allows one or two.
+    </t>
+  </list>
+</t>
+<t>
+   [rule]
+  <list>
+    <t>
+      Square brackets enclose optional elements; "[foo bar]" is
+      equivalent to "*1(foo bar)".
+    </t>
+  </list>
+</t>
+<t>
+   N rule
+  <list>
+    <t>
+      Specific repetition: "&lt;n&gt;(element)" is equivalent to
+      "&lt;n&gt;*&lt;n&gt;(element)"; that is, exactly &lt;n&gt; occurrences of (element).
+      Thus 2DIGIT is a 2-digit number, and 3ALPHA is a string of three
+      alphabetic characters.
+    </t>
+  </list>
+</t>
+<t>
+   #rule
+  <list>
+    <t>
+      A construct "#" is defined, similar to "*", for defining lists of
+      elements. The full form is "&lt;n&gt;#&lt;m&gt;element" indicating at least
+      &lt;n&gt; and at most &lt;m&gt; elements, each separated by one or more commas
+      (",") and &OPTIONAL; linear white space (LWS). This makes the usual
+      form of lists very easy; a rule such as
+    </t>
+    <t>
+         ( *LWS element *( *LWS "," *LWS element ))
+    </t>
+    <t>
+      can be shown as
+    </t>
+    <t>
+         1#element
+    </t>
+    <t>
+      Wherever this construct is used, null elements are allowed, but do
+      not contribute to the count of elements present. That is,
+      "(element), , (element) " is permitted, but counts as only two
+      elements. Therefore, where at least one element is required, at
+      least one non-null element &MUST; be present. Default values are 0
+      and infinity so that "#element" allows any number, including zero;
+      "1#element" requires at least one; and "1#2element" allows one or
+      two.
+    </t>
+  </list>
+</t>
+<t>
+   ; comment
+  <list>
+    <t>
+      A semi-colon, set off some distance to the right of rule text,
+      starts a comment that continues to the end of line. This is a
+      simple way of including useful notes in parallel with the
+      specifications.
+    </t>
+  </list>
+</t>
+<t>
+   implied *LWS
+  <list>
+    <t>
+      The grammar described by this specification is word-based. Except
+      where noted otherwise, linear white space (LWS) can be included
+      between any two adjacent words (token or quoted-string), and
+      between adjacent words and separators, without changing the
+      interpretation of a field. At least one delimiter (LWS and/or
+      separators) &MUST; exist between any two tokens (for the definition
+      of "token" below), since they would otherwise be interpreted as a
+      single token.
+    </t>
+  </list>
+</t>
+</section>
+
+<section title="Basic Rules" anchor="basic.rules">
+<x:anchor-alias value="OCTET"/>
+<x:anchor-alias value="CHAR"/>
+<x:anchor-alias value="UPALPHA"/>
+<x:anchor-alias value="LOALPHA"/>
+<x:anchor-alias value="ALPHA"/>
+<x:anchor-alias value="DIGIT"/>
+<x:anchor-alias value="CTL"/>
+<x:anchor-alias value="CR"/>
+<x:anchor-alias value="LF"/>
+<x:anchor-alias value="SP"/>
+<x:anchor-alias value="HT"/>
+<x:anchor-alias value="CRLF"/>
+<x:anchor-alias value="LWS"/>
+<x:anchor-alias value="TEXT"/>
+<x:anchor-alias value="HEX"/>
+<x:anchor-alias value="token"/>
+<x:anchor-alias value="separators"/>
+<x:anchor-alias value="comment"/>
+<x:anchor-alias value="ctext"/>
+<x:anchor-alias value="quoted-string"/>
+<x:anchor-alias value="qdtext"/>
+<x:anchor-alias value="quoted-pair"/>
+<t>
+   The following rules are used throughout this specification to
+   describe basic parsing constructs. The US-ASCII coded character set
+   is defined by ANSI X3.4-1986 <xref target="USASCII"/>.
+</t>
+<figure><artwork type="abnf2616"><iref primary="true" item="Grammar" subitem="OCTET"/><iref primary="true" item="Grammar" subitem="CHAR"/><iref primary="true" item="Grammar" subitem="UPALPHA"/><iref primary="true" item="Grammar" subitem="LOALPHA"/><iref primary="true" item="Grammar" subitem="ALPHA"/><iref primary="true" item="Grammar" subitem="DIGIT"/><iref primary="true" item="Grammar" subitem="CTL"/><iref primary="true" item="Grammar" subitem="CR"/><iref primary="true" item="Grammar" subitem="LF"/><iref primary="true" item="Grammar" subitem="SP"/><iref primary="true" item="Grammar" subitem="HT"/>
+    OCTET          = &lt;any 8-bit sequence of data&gt;
+    CHAR           = &lt;any US-ASCII character (octets 0 - 127)&gt;
+    UPALPHA        = &lt;any US-ASCII uppercase letter "A".."Z"&gt;
+    LOALPHA        = &lt;any US-ASCII lowercase letter "a".."z"&gt;
+    ALPHA          = UPALPHA | LOALPHA
+    DIGIT          = &lt;any US-ASCII digit "0".."9"&gt;
+    CTL            = &lt;any US-ASCII control character
+                     (octets 0 - 31) and DEL (127)&gt;
+    CR             = &lt;US-ASCII CR, carriage return (13)&gt;
+    LF             = &lt;US-ASCII LF, linefeed (10)&gt;
+    SP             = &lt;US-ASCII SP, space (32)&gt;
+    HT             = &lt;US-ASCII HT, horizontal-tab (9)&gt;
+    &lt;"&gt;            = &lt;US-ASCII double-quote mark (34)&gt;
+</artwork></figure>
+<t>
+   HTTP/1.1 defines the sequence CR LF as the end-of-line marker for all
+   protocol elements except the entity-body (see <xref target="tolerant.applications"/> for
+   tolerant applications). The end-of-line marker within an entity-body
+   is defined by its associated media type, as described in &payload;.
+</t>
+<figure><artwork type="abnf2616"><iref primary="true" item="Grammar" subitem="CRLF"/>
+    CRLF           = CR LF
+</artwork></figure>
+<t>
+   HTTP/1.1 header field values can be folded onto multiple lines if the
+   continuation line begins with a space or horizontal tab. All linear
+   white space, including folding, has the same semantics as SP. A
+   recipient &MAY; replace any linear white space with a single SP before
+   interpreting the field value or forwarding the message downstream.
+</t>
+<figure><artwork type="abnf2616"><iref primary="true" item="Grammar" subitem="LWS"/>
+    LWS            = [CRLF] 1*( SP | HT )
+</artwork></figure>
+<t>
+   The TEXT rule is only used for descriptive field contents and values
+   that are not intended to be interpreted by the message parser. Words
+   of *TEXT &MAY; contain characters from character sets other than ISO-8859-1
+   <xref target="ISO-8859"/> only when encoded according to the rules of RFC 2047
+   <xref target="RFC2047"/>.
+</t>
+<figure><artwork type="abnf2616"><iref primary="true" item="Grammar" subitem="TEXT"/>
+    TEXT           = &lt;any OCTET except CTLs,
+                     but including LWS&gt;
+</artwork></figure>
+<t>
+   A CRLF is allowed in the definition of TEXT only as part of a header
+   field continuation. It is expected that the folding LWS will be
+   replaced with a single SP before interpretation of the TEXT value.
+</t>
+<t>
+   Hexadecimal numeric characters are used in several protocol elements.
+</t>
+<figure><artwork type="abnf2616"><iref primary="true" item="Grammar" subitem="HEX"/>
+    HEX            = "A" | "B" | "C" | "D" | "E" | "F"
+                   | "a" | "b" | "c" | "d" | "e" | "f" | DIGIT
+</artwork></figure>
+<t>
+   Many HTTP/1.1 header field values consist of words separated by LWS
+   or special characters. These special characters &MUST; be in a quoted
+   string to be used within a parameter value (as defined in
+   <xref target="transfer.codings"/>).
+</t>
+<figure><artwork type="abnf2616"><iref primary="true" item="Grammar" subitem="token"/><iref primary="true" item="Grammar" subitem="separators"/>
+    token          = 1*&lt;any CHAR except CTLs or separators&gt;
+    separators     = "(" | ")" | "&lt;" | "&gt;" | "@"
+                   | "," | ";" | ":" | "\" | &lt;"&gt;
+                   | "/" | "[" | "]" | "?" | "="
+                   | "{" | "}" | SP | HT
+</artwork></figure>
+<t>
+   Comments can be included in some HTTP header fields by surrounding
+   the comment text with parentheses. Comments are only allowed in
+   fields containing "comment" as part of their field value definition.
+   In all other fields, parentheses are considered part of the field
+   value.
+</t>
+<figure><artwork type="abnf2616"><iref primary="true" item="Grammar" subitem="comment"/><iref primary="true" item="Grammar" subitem="ctext"/>
+    comment        = "(" *( ctext | quoted-pair | comment ) ")"
+    ctext          = &lt;any TEXT excluding "(" and ")"&gt;
+</artwork></figure>
+<t>
+   A string of text is parsed as a single word if it is quoted using
+   double-quote marks.
+</t>
+<figure><artwork type="abnf2616"><iref primary="true" item="Grammar" subitem="quoted-string"/><iref primary="true" item="Grammar" subitem="qdtext"/>
+    quoted-string  = ( &lt;"&gt; *(qdtext | quoted-pair ) &lt;"&gt; )
+    qdtext         = &lt;any TEXT except &lt;"&gt;&gt;
+</artwork></figure>
+<t>
+   The backslash character ("\") &MAY; be used as a single-character
+   quoting mechanism only within quoted-string and comment constructs.
+</t>
+<figure><artwork type="abnf2616"><iref primary="true" item="Grammar" subitem="quoted-pair"/>
+    quoted-pair    = "\" CHAR
+</artwork></figure>
+</section>
+</section>
+
+<section title="Protocol Parameters" anchor="protocol.parameters">
+
+<section title="HTTP Version" anchor="http.version">
+<t>
+   HTTP uses a "&lt;major&gt;.&lt;minor&gt;" numbering scheme to indicate versions
+   of the protocol. The protocol versioning policy is intended to allow
+   the sender to indicate the format of a message and its capacity for
+   understanding further HTTP communication, rather than the features
+   obtained via that communication. No change is made to the version
+   number for the addition of message components which do not affect
+   communication behavior or which only add to extensible field values.
+   The &lt;minor&gt; number is incremented when the changes made to the
+   protocol add features which do not change the general message parsing
+   algorithm, but which may add to the message semantics and imply
+   additional capabilities of the sender. The &lt;major&gt; number is
+   incremented when the format of a message within the protocol is
+   changed. See RFC 2145 <xref target="RFC2145"/> for a fuller explanation.
+</t>
+<t>
+   The version of an HTTP message is indicated by an HTTP-Version field
+   in the first line of the message.
+</t>
+<figure><artwork type="abnf2616"><iref primary="true" item="Grammar" subitem="HTTP-Version"/>
+       HTTP-Version   = "HTTP" "/" 1*DIGIT "." 1*DIGIT
+</artwork></figure>
+<t>
+   Note that the major and minor numbers &MUST; be treated as separate
+   integers and that each &MAY; be incremented higher than a single digit.
+   Thus, HTTP/2.4 is a lower version than HTTP/2.13, which in turn is
+   lower than HTTP/12.3. Leading zeros &MUST; be ignored by recipients and
+   &MUST-NOT; be sent.
+</t>
+<t>
+   An application that sends a request or response message that includes
+   HTTP-Version of "HTTP/1.1" &MUST; be at least conditionally compliant
+   with this specification. Applications that are at least conditionally
+   compliant with this specification &SHOULD; use an HTTP-Version of
+   "HTTP/1.1" in their messages, and &MUST; do so for any message that is
+   not compatible with HTTP/1.0. For more details on when to send
+   specific HTTP-Version values, see RFC 2145 <xref target="RFC2145"/>.
+</t>
+<t>
+   The HTTP version of an application is the highest HTTP version for
+   which the application is at least conditionally compliant.
+</t>
+<t>
+   Proxy and gateway applications need to be careful when forwarding
+   messages in protocol versions different from that of the application.
+   Since the protocol version indicates the protocol capability of the
+   sender, a proxy/gateway &MUST-NOT; send a message with a version
+   indicator which is greater than its actual version. If a higher
+   version request is received, the proxy/gateway &MUST; either downgrade
+   the request version, or respond with an error, or switch to tunnel
+   behavior.
+</t>
+<t>
+   Due to interoperability problems with HTTP/1.0 proxies discovered
+   since the publication of RFC 2068 <xref target="RFC2068"/>, caching proxies MUST, gateways
+   &MAY;, and tunnels &MUST-NOT; upgrade the request to the highest version
+   they support. The proxy/gateway's response to that request &MUST; be in
+   the same major version as the request.
+</t>
+<t>
+  <list>
+    <t>
+      <x:h>Note:</x:h> Converting between versions of HTTP may involve modification
+      of header fields required or forbidden by the versions involved.
+    </t>
+  </list>
+</t>
+</section>
+
+<section title="Uniform Resource Identifiers" anchor="uri">
+<t>
+   URIs have been known by many names: WWW addresses, Universal Document
+   Identifiers, Universal Resource Identifiers <xref target="RFC1630"/>, and finally the
+   combination of Uniform Resource Locators (URL) <xref target="RFC1738"/> and Names (URN)
+   <xref target="RFC1737"/>. As far as HTTP is concerned, Uniform Resource Identifiers are
+   simply formatted strings which identify--via name, location, or any
+   other characteristic--a resource.
+</t>
+
+<section title="General Syntax" anchor="general.syntax">
+<t>
+   URIs in HTTP can be represented in absolute form or relative to some
+   known base URI <xref target="RFC1808"/>, depending upon the context of their use. The two
+   forms are differentiated by the fact that absolute URIs always begin
+   with a scheme name followed by a colon. For definitive information on
+   URL syntax and semantics, see "Uniform Resource Identifiers (URI):
+   Generic Syntax and Semantics," RFC 2396 <xref target="RFC2396"/> (which replaces RFCs
+   1738 <xref target="RFC1738"/> and RFC 1808 <xref target="RFC1808"/>). This specification adopts the
+   definitions of "URI-reference", "absoluteURI", "relativeURI", "port",
+   "host","abs_path", "rel_path", and "authority" from that
+   specification.
+</t>
+<t>
+   The HTTP protocol does not place any a priori limit on the length of
+   a URI. Servers &MUST; be able to handle the URI of any resource they
+   serve, and &SHOULD; be able to handle URIs of unbounded length if they
+   provide GET-based forms that could generate such URIs. A server
+   &SHOULD; return 414 (Request-URI Too Long) status if a URI is longer
+   than the server can handle (see &status-414;).
+</t>
+<t>
+  <list>
+    <t>
+      <x:h>Note:</x:h> Servers ought to be cautious about depending on URI lengths
+      above 255 bytes, because some older client or proxy
+      implementations might not properly support these lengths.
+    </t>
+  </list>
+</t>
+</section>
+
+<section title="http URL" anchor="http.url">
+<t>
+   The "http" scheme is used to locate network resources via the HTTP
+   protocol. This section defines the scheme-specific syntax and
+   semantics for http URLs.
+</t>
+<figure><artwork type="abnf2616"><iref primary="true" item="Grammar" subitem="http_URL"/>
+http_URL = "http:" "//" host [ ":" port ] [ abs_path [ "?" query ]]
+</artwork></figure>
+<t>
+   If the port is empty or not given, port 80 is assumed. The semantics
+   are that the identified resource is located at the server listening
+   for TCP connections on that port of that host, and the Request-URI
+   for the resource is abs_path (<xref target="request-uri"/>). The use of IP addresses
+   in URLs &SHOULD; be avoided whenever possible (see RFC 1900 <xref target="RFC1900"/>). If
+   the abs_path is not present in the URL, it &MUST; be given as "/" when
+   used as a Request-URI for a resource (<xref target="request-uri"/>). If a proxy
+
+   receives a host name which is not a fully qualified domain name, it
+   &MAY; add its domain to the host name it received. If a proxy receives
+   a fully qualified domain name, the proxy &MUST-NOT; change the host
+   name.
+</t>
+</section>
+
+<section title="URI Comparison" anchor="uri.comparison">
+<t>
+   When comparing two URIs to decide if they match or not, a client
+   &SHOULD; use a case-sensitive octet-by-octet comparison of the entire
+   URIs, with these exceptions:
+  <list style="symbols">
+    <t>A port that is empty or not given is equivalent to the default
+        port for that URI-reference;</t>
+    <t>Comparisons of host names &MUST; be case-insensitive;</t>
+    <t>Comparisons of scheme names &MUST; be case-insensitive;</t>
+    <t>An empty abs_path is equivalent to an abs_path of "/".</t>
+  </list>
+</t>
+<t>
+   Characters other than those in the "reserved" and "unsafe" sets (see
+   RFC 2396 <xref target="RFC2396"/>) are equivalent to their ""%" HEX HEX" encoding.
+</t>
+<t>
+   For example, the following three URIs are equivalent:
+</t>
+<figure><artwork type="example">
+   http://abc.com:80/~smith/home.html
+   http://ABC.com/%7Esmith/home.html
+   http://ABC.com:/%7esmith/home.html
+</artwork></figure>
+</section>
+</section>
+
+<section title="Date/Time Formats" anchor="date.time.formats">
+<section title="Full Date" anchor="full.date">
+<t>
+   HTTP applications have historically allowed three different formats
+   for the representation of date/time stamps:
+</t>
+<figure><artwork type="example">
+   Sun, 06 Nov 1994 08:49:37 GMT  ; RFC 822, updated by RFC 1123
+   Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036
+   Sun Nov  6 08:49:37 1994       ; ANSI C's asctime() format
+</artwork></figure>
+<t>
+   The first format is preferred as an Internet standard and represents
+   a fixed-length subset of that defined by RFC 1123 <xref target="RFC1123"/> (an update to
+   RFC 822 <xref target="RFC822"/>). The second format is in common use, but is based on the
+   obsolete RFC 850 <xref target="RFC1036"/> date format and lacks a four-digit year.
+   HTTP/1.1 clients and servers that parse the date value &MUST; accept
+   all three formats (for compatibility with HTTP/1.0), though they &MUST;
+   only generate the RFC 1123 format for representing HTTP-date values
+   in header fields. See <xref target="tolerant.applications"/> for further information.
+</t>
+<t><list><t>
+      <x:h>Note:</x:h> Recipients of date values are encouraged to be robust in
+      accepting date values that may have been sent by non-HTTP
+      applications, as is sometimes the case when retrieving or posting
+      messages via proxies/gateways to SMTP or NNTP.
+</t></list></t>
+<t>
+   All HTTP date/time stamps &MUST; be represented in Greenwich Mean Time
+   (GMT), without exception. For the purposes of HTTP, GMT is exactly
+   equal to UTC (Coordinated Universal Time). This is indicated in the
+   first two formats by the inclusion of "GMT" as the three-letter
+   abbreviation for time zone, and &MUST; be assumed when reading the
+   asctime format. HTTP-date is case sensitive and &MUST-NOT; include
+   additional LWS beyond that specifically included as SP in the
+   grammar.
+</t>
+<figure><artwork type="abnf2616"><iref primary="true" item="Grammar" subitem="HTTP-date"/><iref primary="true" item="Grammar" subitem="rfc1123-date"/><iref primary="true" item="Grammar" subitem="rfc850-date"/><iref primary="true" item="Grammar" subitem="asctime-date"/><iref primary="true" item="Grammar" subitem="date1"/><iref primary="true" item="Grammar" subitem="date2"/><iref primary="true" item="Grammar" subitem="date3"/><iref primary="true" item="Grammar" subitem="time"/><iref primary="true" item="Grammar" subitem="wkday"/><iref primary="true" item="Grammar" subitem="weekday"/><iref primary="true" item="Grammar" subitem="month"/>
+    HTTP-date    = rfc1123-date | rfc850-date | asctime-date
+    rfc1123-date = wkday "," SP date1 SP time SP "GMT"
+    rfc850-date  = weekday "," SP date2 SP time SP "GMT"
+    asctime-date = wkday SP date3 SP time SP 4DIGIT
+    date1        = 2DIGIT SP month SP 4DIGIT
+                   ; day month year (e.g., 02 Jun 1982)
+    date2        = 2DIGIT "-" month "-" 2DIGIT
+                   ; day-month-year (e.g., 02-Jun-82)
+    date3        = month SP ( 2DIGIT | ( SP 1DIGIT ))
+                   ; month day (e.g., Jun  2)
+    time         = 2DIGIT ":" 2DIGIT ":" 2DIGIT
+                   ; 00:00:00 - 23:59:59
+    wkday        = "Mon" | "Tue" | "Wed"
+                 | "Thu" | "Fri" | "Sat" | "Sun"
+    weekday      = "Monday" | "Tuesday" | "Wednesday"
+                 | "Thursday" | "Friday" | "Saturday" | "Sunday"
+    month        = "Jan" | "Feb" | "Mar" | "Apr"
+                 | "May" | "Jun" | "Jul" | "Aug"
+                 | "Sep" | "Oct" | "Nov" | "Dec"
+</artwork></figure>
+<t>
+      <x:h>Note:</x:h> HTTP requirements for the date/time stamp format apply only
+      to their usage within the protocol stream. Clients and servers are
+      not required to use these formats for user presentation, request
+      logging, etc.
+</t>
+</section>
+</section>
+
+<section title="Transfer Codings" anchor="transfer.codings">
+<t>
+   Transfer-coding values are used to indicate an encoding
+   transformation that has been, can be, or may need to be applied to an
+   entity-body in order to ensure "safe transport" through the network.
+   This differs from a content coding in that the transfer-coding is a
+   property of the message, not of the original entity.
+</t>
+<figure><artwork type="abnf2616"><iref primary="true" item="Grammar" subitem="transfer-coding"/><iref primary="true" item="Grammar" subitem="transfer-extension"/>
+    transfer-coding         = "chunked" | transfer-extension
+    transfer-extension      = token *( ";" parameter )
+</artwork></figure>
+<t>
+   Parameters are in  the form of attribute/value pairs.
+</t>
+<figure><artwork type="abnf2616"><iref primary="true" item="Grammar" subitem="parameter"/><iref primary="true" item="Grammar" subitem="attribute"/><iref primary="true" item="Grammar" subitem="value"/>
+    parameter               = attribute "=" value
+    attribute               = token
+    value                   = token | quoted-string
+</artwork></figure>
+<t>
+   All transfer-coding values are case-insensitive. HTTP/1.1 uses
+   transfer-coding values in the TE header field (<xref target="header.te"/>) and in
+   the Transfer-Encoding header field (<xref target="header.transfer-encoding"/>).
+</t>
+<t>
+   Whenever a transfer-coding is applied to a message-body, the set of
+   transfer-codings &MUST; include "chunked", unless the message is
+   terminated by closing the connection. When the "chunked" transfer-coding
+   is used, it &MUST; be the last transfer-coding applied to the
+   message-body. The "chunked" transfer-coding &MUST-NOT; be applied more
+   than once to a message-body. These rules allow the recipient to
+   determine the transfer-length of the message (<xref target="message.length"/>).
+</t>
+<t>
+   Transfer-codings are analogous to the Content-Transfer-Encoding
+   values of MIME <xref target="RFC2045"/>, which were designed to enable safe transport of
+   binary data over a 7-bit transport service. However, safe transport
+   has a different focus for an 8bit-clean transfer protocol. In HTTP,
+   the only unsafe characteristic of message-bodies is the difficulty in
+   determining the exact body length (<xref target="message.length"/>), or the desire to
+   encrypt data over a shared transport.
+</t>
+<t>
+   The Internet Assigned Numbers Authority (IANA) acts as a registry for
+   transfer-coding value tokens. Initially, the registry contains the
+   following tokens: "chunked" (<xref target="chunked.transfer.encoding"/>), "identity" (section
+   3.6.2), "gzip" (&payload;), "compress" (&payload;), and "deflate"
+   (&payload;).
+</t>
+<t>
+   New transfer-coding value tokens &SHOULD; be registered in the same way
+   as new content-coding value tokens (&payload;).
+</t>
+<t>
+   A server which receives an entity-body with a transfer-coding it does
+   not understand &SHOULD; return 501 (Unimplemented), and close the
+   connection. A server &MUST-NOT; send transfer-codings to an HTTP/1.0
+   client.
+</t>
+
+<section title="Chunked Transfer Coding" anchor="chunked.transfer.encoding">
+<t>
+   The chunked encoding modifies the body of a message in order to
+   transfer it as a series of chunks, each with its own size indicator,
+   followed by an &OPTIONAL; trailer containing entity-header fields. This
+   allows dynamically produced content to be transferred along with the
+   information necessary for the recipient to verify that it has
+   received the full message.
+</t>
+<figure><artwork type="abnf2616"><iref primary="true" item="Grammar" subitem="Chunked-Body"/><iref primary="true" item="Grammar" subitem="chunk"/><iref primary="true" item="Grammar" subitem="chunk-size"/><iref primary="true" item="Grammar" subitem="last-chunk"/><iref primary="true" item="Grammar" subitem="chunk-extension"/><iref primary="true" item="Grammar" subitem="chunk-ext-name"/><iref primary="true" item="Grammar" subitem="chunk-ext-val"/><iref primary="true" item="Grammar" subitem="chunk-data"/><iref primary="true" item="Grammar" subitem="trailer"/>
+    Chunked-Body   = *chunk
+                     last-chunk
+                     trailer
+                     CRLF
+
+    chunk          = chunk-size [ chunk-extension ] CRLF
+                     chunk-data CRLF
+    chunk-size     = 1*HEX
+    last-chunk     = 1*("0") [ chunk-extension ] CRLF
+
+    chunk-extension= *( ";" chunk-ext-name [ "=" chunk-ext-val ] )
+    chunk-ext-name = token
+    chunk-ext-val  = token | quoted-string
+    chunk-data     = chunk-size(OCTET)
+    trailer        = *(entity-header CRLF)
+</artwork></figure>
+<t>
+   The chunk-size field is a string of hex digits indicating the size of
+   the chunk. The chunked encoding is ended by any chunk whose size is
+   zero, followed by the trailer, which is terminated by an empty line.
+</t>
+<t>
+   The trailer allows the sender to include additional HTTP header
+   fields at the end of the message. The Trailer header field can be
+   used to indicate which header fields are included in a trailer (see
+   <xref target="header.trailer"/>).
+</t>
+<t>
+   A server using chunked transfer-coding in a response &MUST-NOT; use the
+   trailer for any header fields unless at least one of the following is
+   true:
+  <list style="numbers">
+    <t>the request included a TE header field that indicates "trailers" is
+     acceptable in the transfer-coding of the  response, as described in
+     <xref target="header.te"/>; or,</t>
+
+    <t>the server is the origin server for the response, the trailer
+     fields consist entirely of optional metadata, and the recipient
+     could use the message (in a manner acceptable to the origin server)
+     without receiving this metadata.  In other words, the origin server
+     is willing to accept the possibility that the trailer fields might
+     be silently discarded along the path to the client.</t>
+  </list>
+</t>
+<t>
+   This requirement prevents an interoperability failure when the
+   message is being received by an HTTP/1.1 (or later) proxy and
+   forwarded to an HTTP/1.0 recipient. It avoids a situation where
+   compliance with the protocol would have necessitated a possibly
+   infinite buffer on the proxy.
+</t>
+<t>
+   A process for decoding the "chunked" transfer-coding
+   can be represented in pseudo-code as:
+</t>
+<figure><artwork type="code">
+    length := 0
+    read chunk-size, chunk-extension (if any) and CRLF
+    while (chunk-size &gt; 0) {
+       read chunk-data and CRLF
+       append chunk-data to entity-body
+       length := length + chunk-size
+       read chunk-size and CRLF
+    }
+    read entity-header
+    while (entity-header not empty) {
+       append entity-header to existing header fields
+       read entity-header
+    }
+    Content-Length := length
+    Remove "chunked" from Transfer-Encoding
+</artwork></figure>
+<t>
+   All HTTP/1.1 applications &MUST; be able to receive and decode the
+   "chunked" transfer-coding, and &MUST; ignore chunk-extension extensions
+   they do not understand.
+</t>
+</section>
+</section>
+
+</section>
+
+<section title="HTTP Message" anchor="http.message">
+
+<section title="Message Types" anchor="message.types">
+<t>
+   HTTP messages consist of requests from client to server and responses
+   from server to client.
+</t>
+<figure><artwork type="abnf2616"><iref primary="true" item="Grammar" subitem="HTTP-message"/>
+    HTTP-message   = Request | Response     ; HTTP/1.1 messages
+</artwork></figure>
+<t>
+   Request (<xref target="request"/>) and Response (<xref target="response"/>) messages use the generic
+   message format of RFC 822 <xref target="RFC822"/> for transferring entities (the payload
+   of the message). Both types of message consist of a start-line, zero
+   or more header fields (also known as "headers"), an empty line (i.e.,
+   a line with nothing preceding the CRLF) indicating the end of the
+   header fields, and possibly a message-body.
+</t>
+<figure><artwork type="abnf2616"><iref primary="true" item="Grammar" subitem="generic-message"/><iref primary="true" item="Grammar" subitem="start-line"/>
+     generic-message = start-line
+                       *(message-header CRLF)
+                       CRLF
+                       [ message-body ]
+     start-line      = Request-Line | Status-Line
+</artwork></figure>
+<t>
+   In the interest of robustness, servers &SHOULD; ignore any empty
+   line(s) received where a Request-Line is expected. In other words, if
+   the server is reading the protocol stream at the beginning of a
+   message and receives a CRLF first, it should ignore the CRLF.
+</t>
+<t>
+   Certain buggy HTTP/1.0 client implementations generate extra CRLF's
+   after a POST request. To restate what is explicitly forbidden by the
+   BNF, an HTTP/1.1 client &MUST-NOT; preface or follow a request with an
+   extra CRLF.
+</t>
+</section>
+
+<section title="Message Headers" anchor="message.headers">
+<t>
+   HTTP header fields, which include general-header (<xref target="general.header.fields"/>),
+   request-header (&request-header-fields;), response-header (&response-header-fields;), and
+   entity-header (&entity-header-fields;) fields, follow the same generic format as
+   that given in <xref target="RFC822" x:fmt="sec" x:sec="3.1"/> of RFC 822 <xref target="RFC822"/>. Each header field consists
+   of a name followed by a colon (":") and the field value. Field names
+   are case-insensitive. The field value &MAY; be preceded by any amount
+   of LWS, though a single SP is preferred. Header fields can be
+   extended over multiple lines by preceding each extra line with at
+   least one SP or HT. Applications ought to follow "common form", where
+   one is known or indicated, when generating HTTP constructs, since
+   there might exist some implementations that fail to accept anything
+   beyond the common forms.
+</t>
+<figure><artwork type="abnf2616"><iref primary="true" item="Grammar" subitem="message-header"/><iref primary="true" item="Grammar" subitem="field-name"/><iref primary="true" item="Grammar" subitem="field-value"/><iref primary="true" item="Grammar" subitem="field-content"/>
+    message-header = field-name ":" [ field-value ]
+    field-name     = token
+    field-value    = *( field-content | LWS )
+    field-content  = &lt;the OCTETs making up the field-value
+                     and consisting of either *TEXT or combinations
+                     of token, separators, and quoted-string&gt;
+</artwork></figure>
+<t>
+   The field-content does not include any leading or trailing LWS:
+   linear white space occurring before the first non-whitespace
+   character of the field-value or after the last non-whitespace
+   character of the field-value. Such leading or trailing LWS &MAY; be
+   removed without changing the semantics of the field value. Any LWS
+   that occurs between field-content &MAY; be replaced with a single SP
+   before interpreting the field value or forwarding the message
+   downstream.
+</t>
+<t>
+   The order in which header fields with differing field names are
+   received is not significant. However, it is "good practice" to send
+   general-header fields first, followed by request-header or response-header
+   fields, and ending with the entity-header fields.
+</t>
+<t>
+   Multiple message-header fields with the same field-name &MAY; be
+   present in a message if and only if the entire field-value for that
+   header field is defined as a comma-separated list [i.e., #(values)].
+   It &MUST; be possible to combine the multiple header fields into one
+   "field-name: field-value" pair, without changing the semantics of the
+   message, by appending each subsequent field-value to the first, each
+   separated by a comma. The order in which header fields with the same
+   field-name are received is therefore significant to the
+   interpretation of the combined field value, and thus a proxy &MUST-NOT;
+   change the order of these field values when a message is forwarded.
+</t>
+</section>
+
+<section title="Message Body" anchor="message.body">
+<t>
+   The message-body (if any) of an HTTP message is used to carry the
+   entity-body associated with the request or response. The message-body
+   differs from the entity-body only when a transfer-coding has been
+   applied, as indicated by the Transfer-Encoding header field (<xref target="header.transfer-encoding"/>).
+</t>
+<figure><artwork type="abnf2616"><iref primary="true" item="Grammar" subitem="message-body"/>
+    message-body = entity-body
+                 | &lt;entity-body encoded as per Transfer-Encoding&gt;
+</artwork></figure>
+<t>
+   Transfer-Encoding &MUST; be used to indicate any transfer-codings
+   applied by an application to ensure safe and proper transfer of the
+   message. Transfer-Encoding is a property of the message, not of the
+   entity, and thus &MAY; be added or removed by any application along the
+   request/response chain. (However, <xref target="transfer.codings"/> places restrictions on
+   when certain transfer-codings may be used.)
+</t>
+<t>
+   The rules for when a message-body is allowed in a message differ for
+   requests and responses.
+</t>
+<t>
+   The presence of a message-body in a request is signaled by the
+   inclusion of a Content-Length or Transfer-Encoding header field in
+   the request's message-headers. A message-body &MUST-NOT; be included in
+   a request if the specification of the request method (&method;)
+   does not allow sending an entity-body in requests. A server &SHOULD;
+   read and forward a message-body on any request; if the request method
+   does not include defined semantics for an entity-body, then the
+   message-body &SHOULD; be ignored when handling the request.
+</t>
+<t>
+   For response messages, whether or not a message-body is included with
+   a message is dependent on both the request method and the response
+   status code (<xref target="status.code.and.reason.phrase"/>). All responses to the HEAD request method
+   &MUST-NOT; include a message-body, even though the presence of entity-header
+   fields might lead one to believe they do. All 1xx
+   (informational), 204 (no content), and 304 (not modified) responses
+   &MUST-NOT; include a message-body. All other responses do include a
+   message-body, although it &MAY; be of zero length.
+</t>
+</section>
+
+<section title="Message Length" anchor="message.length">
+<t>
+   The transfer-length of a message is the length of the message-body as
+   it appears in the message; that is, after any transfer-codings have
+   been applied. When a message-body is included with a message, the
+   transfer-length of that body is determined by one of the following
+   (in order of precedence):
+</t>
+<t>
+  <list style="numbers">
+    <x:lt><t>
+     Any response message which "&MUST-NOT;" include a message-body (such
+     as the 1xx, 204, and 304 responses and any response to a HEAD
+     request) is always terminated by the first empty line after the
+     header fields, regardless of the entity-header fields present in
+     the message.
+    </t></x:lt>
+    <x:lt><t>
+     If a Transfer-Encoding header field (<xref target="header.transfer-encoding"/>) is present and
+     has any value other than "identity", then the transfer-length is
+     defined by use of the "chunked" transfer-coding (<xref target="transfer.codings"/>),
+     unless the message is terminated by closing the connection.
+    </t></x:lt>
+    <x:lt><t>
+     If a Content-Length header field (<xref target="header.content-length"/>) is present, its
+     decimal value in OCTETs represents both the entity-length and the
+     transfer-length. The Content-Length header field &MUST-NOT; be sent
+     if these two lengths are different (i.e., if a Transfer-Encoding
+     header field is present). If a message is received with both a
+     Transfer-Encoding header field and a Content-Length header field,
+     the latter &MUST; be ignored.
+    </t></x:lt>
+    <x:lt><t>
+     If the message uses the media type "multipart/byteranges", and the
+     ransfer-length is not otherwise specified, then this self-elimiting
+     media type defines the transfer-length. This media type
+     UST NOT be used unless the sender knows that the recipient can arse
+     it; the presence in a request of a Range header with ultiple byte-range
+     specifiers from a 1.1 client implies that the lient can parse
+     multipart/byteranges responses.
+    <list style="empty"><t>
+       A range header might be forwarded by a 1.0 proxy that does not
+       understand multipart/byteranges; in this case the server &MUST;
+       delimit the message using methods defined in items 1, 3 or 5 of
+       this section.
+    </t></list>
+    </t></x:lt>
+    <x:lt><t>
+     By the server closing the connection. (Closing the connection
+     cannot be used to indicate the end of a request body, since that
+     would leave no possibility for the server to send back a response.)
+    </t></x:lt>
+  </list>
+</t>
+<t>
+   For compatibility with HTTP/1.0 applications, HTTP/1.1 requests
+   containing a message-body &MUST; include a valid Content-Length header
+   field unless the server is known to be HTTP/1.1 compliant. If a
+   request contains a message-body and a Content-Length is not given,
+   the server &SHOULD; respond with 400 (bad request) if it cannot
+   determine the length of the message, or with 411 (length required) if
+   it wishes to insist on receiving a valid Content-Length.
+</t>
+<t>
+   All HTTP/1.1 applications that receive entities &MUST; accept the
+   "chunked" transfer-coding (<xref target="transfer.codings"/>), thus allowing this mechanism
+   to be used for messages when the message length cannot be determined
+   in advance.
+</t>
+<t>
+   Messages &MUST-NOT; include both a Content-Length header field and a
+   non-identity transfer-coding. If the message does include a non-identity
+   transfer-coding, the Content-Length &MUST; be ignored.
+</t>
+<t>
+   When a Content-Length is given in a message where a message-body is
+   allowed, its field value &MUST; exactly match the number of OCTETs in
+   the message-body. HTTP/1.1 user agents &MUST; notify the user when an
+   invalid length is received and detected.
+</t>
+</section>
+
+<section title="General Header Fields" anchor="general.header.fields">
+<t>
+   There are a few header fields which have general applicability for
+   both request and response messages, but which do not apply to the
+   entity being transferred. These header fields apply only to the
+   message being transmitted.
+</t>
+<figure><artwork type="abnf2616"><iref primary="true" item="Grammar" subitem="general-header"/>
+    general-header = Cache-Control            ; &header-cache-control;
+                   | Connection               ; <xref target="header.connection"/>
+                   | Date                     ; <xref target="header.date"/>
+                   | Pragma                   ; &header-pragma;
+                   | Trailer                  ; <xref target="header.trailer"/>
+                   | Transfer-Encoding        ; <xref target="header.transfer-encoding"/>
+                   | Upgrade                  ; <xref target="header.upgrade"/>
+                   | Via                      ; <xref target="header.via"/>
+                   | Warning                  ; &header-warning;
+</artwork></figure>
+<t>
+   General-header field names can be extended reliably only in
+   combination with a change in the protocol version. However, new or
+   experimental header fields may be given the semantics of general
+   header fields if all parties in the communication recognize them to
+   be general-header fields. Unrecognized header fields are treated as
+   entity-header fields.
+</t>
+</section>
+</section>
+
+<section title="Request" anchor="request">
+<t>
+   A request message from a client to a server includes, within the
+   first line of that message, the method to be applied to the resource,
+   the identifier of the resource, and the protocol version in use.
+</t>
+<!--                 Host                      ; should be moved here eventually -->
+<figure><artwork type="abnf2616"><iref primary="true" item="Grammar" subitem="Request"/>
+     Request       = Request-Line              ; <xref target="request-line"/>
+                     *(( general-header        ; <xref target="general.header.fields"/>
+                      | request-header         ; &request-header-fields;
+                      | entity-header ) CRLF)  ; &entity-header-fields;
+                     CRLF
+                     [ message-body ]          ; <xref target="message.body"/>
+</artwork></figure>
+
+<section title="Request-Line" anchor="request-line">
+<t>
+   The Request-Line begins with a method token, followed by the
+   Request-URI and the protocol version, and ending with CRLF. The
+   elements are separated by SP characters. No CR or LF is allowed
+   except in the final CRLF sequence.
+</t>
+<figure><artwork type="abnf2616"><iref primary="true" item="Grammar" subitem="Request-Line"/>
+     Request-Line   = Method SP Request-URI SP HTTP-Version CRLF
+</artwork></figure>
+
+<section title="Method" anchor="method">
+<t>
+   The Method  token indicates the method to be performed on the
+   resource identified by the Request-URI. The method is case-sensitive.
+</t>
+<figure><artwork type="abnf2616"><iref primary="true" item="Grammar" subitem="Method"/><iref primary="true" item="Grammar" subitem="extension-method"/>
+    Method         = token
+</artwork></figure>
+</section>
+
+<section title="Request-URI" anchor="request-uri">
+<t>
+   The Request-URI is a Uniform Resource Identifier (<xref target="uri"/>) and
+   identifies the resource upon which to apply the request.
+</t>
+<figure><artwork type="abnf2616"><iref primary="true" item="Grammar" subitem="Request-URI"/>
+    Request-URI    = "*" | absoluteURI | abs_path | authority
+</artwork></figure>
+<t>
+   The four options for Request-URI are dependent on the nature of the
+   request. The asterisk "*" means that the request does not apply to a
+   particular resource, but to the server itself, and is only allowed
+   when the method used does not necessarily apply to a resource. One
+   example would be
+</t>
+<figure><artwork type="example">
+    OPTIONS * HTTP/1.1
+</artwork></figure>
+<t>
+   The absoluteURI form is &REQUIRED; when the request is being made to a
+   proxy. The proxy is requested to forward the request or service it
+   from a valid cache, and return the response. Note that the proxy &MAY;
+   forward the request on to another proxy or directly to the server
+   specified by the absoluteURI. In order to avoid request loops, a
+   proxy &MUST; be able to recognize all of its server names, including
+   any aliases, local variations, and the numeric IP address. An example
+   Request-Line would be:
+</t>
+<figure><artwork type="example">
+    GET http://www.w3.org/pub/WWW/TheProject.html HTTP/1.1
+</artwork></figure>
+<t>
+   To allow for transition to absoluteURIs in all requests in future
+   versions of HTTP, all HTTP/1.1 servers &MUST; accept the absoluteURI
+   form in requests, even though HTTP/1.1 clients will only generate
+   them in requests to proxies.
+</t>
+<t>
+   The authority form is only used by the CONNECT method (&CONNECT;).
+</t>
+<t>
+   The most common form of Request-URI is that used to identify a
+   resource on an origin server or gateway. In this case the absolute
+   path of the URI &MUST; be transmitted (see <xref target="general.syntax"/>, abs_path) as
+   the Request-URI, and the network location of the URI (authority) &MUST;
+   be transmitted in a Host header field. For example, a client wishing
+   to retrieve the resource above directly from the origin server would
+   create a TCP connection to port 80 of the host "www.w3.org" and send
+   the lines:
+</t>
+<figure><artwork type="example">
+    GET /pub/WWW/TheProject.html HTTP/1.1
+    Host: www.w3.org
+</artwork></figure>
+<t>
+   followed by the remainder of the Request. Note that the absolute path
+   cannot be empty; if none is present in the original URI, it &MUST; be
+   given as "/" (the server root).
+</t>
+<t>
+   The Request-URI is transmitted in the format specified in 
+   <xref target="general.syntax"/>. If the Request-URI is encoded using the "% HEX HEX" encoding
+   <xref target="RFC2396"/>, the origin server &MUST; decode the Request-URI in order to
+   properly interpret the request. Servers &SHOULD; respond to invalid
+   Request-URIs with an appropriate status code.
+</t>
+<t>
+   A transparent proxy &MUST-NOT; rewrite the "abs_path" part of the
+   received Request-URI when forwarding it to the next inbound server,
+   except as noted above to replace a null abs_path with "/".
+</t>
+<t>
+  <list><t>
+      <x:h>Note:</x:h> The "no rewrite" rule prevents the proxy from changing the
+      meaning of the request when the origin server is improperly using
+      a non-reserved URI character for a reserved purpose.  Implementors
+      should be aware that some pre-HTTP/1.1 proxies have been known to
+      rewrite the Request-URI.
+  </t></list>
+</t>
+</section>
+</section>
+
+<section title="The Resource Identified by a Request" anchor="the.resource.identified.by.a.request">
+<t>
+   The exact resource identified by an Internet request is determined by
+   examining both the Request-URI and the Host header field.
+</t>
+<t>
+   An origin server that does not allow resources to differ by the
+   requested host &MAY; ignore the Host header field value when
+   determining the resource identified by an HTTP/1.1 request. (But see
+   <xref target="changes.to.simplify.multi-homed.web.servers.and.conserve.ip.addresses"/>
+   for other requirements on Host support in HTTP/1.1.)
+</t>
+<t>
+   An origin server that does differentiate resources based on the host
+   requested (sometimes referred to as virtual hosts or vanity host
+   names) &MUST; use the following rules for determining the requested
+   resource on an HTTP/1.1 request:
+  <list style="numbers">
+    <t>If Request-URI is an absoluteURI, the host is part of the
+     Request-URI. Any Host header field value in the request &MUST; be
+     ignored.</t>
+    <t>If the Request-URI is not an absoluteURI, and the request includes
+     a Host header field, the host is determined by the Host header
+     field value.</t>
+    <t>If the host as determined by rule 1 or 2 is not a valid host on
+     the server, the response &MUST; be a 400 (Bad Request) error message.</t>
+  </list>
+</t>
+<t>
+   Recipients of an HTTP/1.0 request that lacks a Host header field &MAY;
+   attempt to use heuristics (e.g., examination of the URI path for
+   something unique to a particular host) in order to determine what
+   exact resource is being requested.
+</t>
+</section>
+
+</section>
+
+
+<section title="Response" anchor="response">
+<t>
+   After receiving and interpreting a request message, a server responds
+   with an HTTP response message.
+</t>
+<figure><artwork type="abnf2616"><iref primary="true" item="Grammar" subitem="Response"/>
+    Response      = Status-Line               ; <xref target="status-line"/>
+                    *(( general-header        ; <xref target="general.header.fields"/>
+                     | response-header        ; &response-header-fields;
+                     | entity-header ) CRLF)  ; &entity-header-fields;
+                    CRLF
+                    [ message-body ]          ; <xref target="message.body"/>
+</artwork></figure>
+
+<section title="Status-Line" anchor="status-line">
+<t>
+   The first line of a Response message is the Status-Line, consisting
+   of the protocol version followed by a numeric status code and its
+   associated textual phrase, with each element separated by SP
+   characters. No CR or LF is allowed except in the final CRLF sequence.
+</t>
+<figure><artwork type="abnf2616"><iref primary="true" item="Grammar" subitem="Status-Line"/>
+    Status-Line = HTTP-Version SP Status-Code SP Reason-Phrase CRLF
+</artwork></figure>
+
+<section title="Status Code and Reason Phrase" anchor="status.code.and.reason.phrase">
+<t>
+   The Status-Code element is a 3-digit integer result code of the
+   attempt to understand and satisfy the request. These codes are fully
+   defined in &status-codes;. The Reason-Phrase is intended to give a short
+   textual description of the Status-Code. The Status-Code is intended
+   for use by automata and the Reason-Phrase is intended for the human
+   user. The client is not required to examine or display the Reason-Phrase.
+</t>
+<t>
+   The first digit of the Status-Code defines the class of response. The
+   last two digits do not have any categorization role. There are 5
+   values for the first digit:
+  <list style="symbols">
+    <t>
+      1xx: Informational - Request received, continuing process
+    </t>
+    <t>
+      2xx: Success - The action was successfully received,
+        understood, and accepted
+    </t>
+    <t>
+      3xx: Redirection - Further action must be taken in order to
+        complete the request
+    </t>
+    <t>
+      4xx: Client Error - The request contains bad syntax or cannot
+        be fulfilled
+    </t>
+    <t>
+      5xx: Server Error - The server failed to fulfill an apparently
+        valid request
+    </t>
+  </list>
+</t>
+<figure><artwork type="abnf2616"><iref primary="true" item="Grammar" subitem="Status-Code"/><iref primary="true" item="Grammar" subitem="extension-code"/><iref primary="true" item="Grammar" subitem="Reason-Phrase"/>
+   Status-Code    = 3DIGIT
+   Reason-Phrase  = *&lt;TEXT, excluding CR, LF&gt;
+</artwork></figure>
+</section>
+</section>
+
+</section>
+
+
+<section title="Connections" anchor="connections">
+
+<section title="Persistent Connections" anchor="persistent.connections">
+
+<section title="Purpose" anchor="persistent.purpose">
+<t>
+   Prior to persistent connections, a separate TCP connection was
+   established to fetch each URL, increasing the load on HTTP servers
+   and causing congestion on the Internet. The use of inline images and
+   other associated data often require a client to make multiple
+   requests of the same server in a short amount of time. Analysis of
+   these performance problems and results from a prototype
+   implementation are available <xref target="Pad1995"/> <xref target="Spe"/>. Implementation experience and
+   measurements of actual HTTP/1.1 (RFC 2068) implementations show good
+   results <xref target="Nie1997"/>. Alternatives have also been explored, for example,
+   T/TCP <xref target="Tou1998"/>.
+</t>
+<t>
+   Persistent HTTP connections have a number of advantages:
+  <list style="symbols">
+      <t>
+        By opening and closing fewer TCP connections, CPU time is saved
+        in routers and hosts (clients, servers, proxies, gateways,
+        tunnels, or caches), and memory used for TCP protocol control
+        blocks can be saved in hosts.
+      </t>
+      <t>
+        HTTP requests and responses can be pipelined on a connection.
+        Pipelining allows a client to make multiple requests without
+        waiting for each response, allowing a single TCP connection to
+        be used much more efficiently, with much lower elapsed time.
+      </t>
+      <t>
+        Network congestion is reduced by reducing the number of packets
+        caused by TCP opens, and by allowing TCP sufficient time to
+        determine the congestion state of the network.
+      </t>
+      <t>
+        Latency on subsequent requests is reduced since there is no time
+        spent in TCP's connection opening handshake.
+      </t>
+      <t>
+        HTTP can evolve more gracefully, since errors can be reported
+        without the penalty of closing the TCP connection. Clients using
+        future versions of HTTP might optimistically try a new feature,
+        but if communicating with an older server, retry with old
+        semantics after an error is reported.
+      </t>
+    </list>
+</t>
+<t>
+   HTTP implementations &SHOULD; implement persistent connections.
+</t>
+</section>
+
+<section title="Overall Operation" anchor="persistent.overall">
+<t>
+   A significant difference between HTTP/1.1 and earlier versions of
+   HTTP is that persistent connections are the default behavior of any
+   HTTP connection. That is, unless otherwise indicated, the client
+   &SHOULD; assume that the server will maintain a persistent connection,
+   even after error responses from the server.
+</t>
+<t>
+   Persistent connections provide a mechanism by which a client and a
+   server can signal the close of a TCP connection. This signaling takes
+   place using the Connection header field (<xref target="header.connection"/>). Once a close
+   has been signaled, the client &MUST-NOT; send any more requests on that
+   connection.
+</t>
+
+<section title="Negotiation" anchor="persistent.negotiation">
+<t>
+   An HTTP/1.1 server &MAY; assume that a HTTP/1.1 client intends to
+   maintain a persistent connection unless a Connection header including
+   the connection-token "close" was sent in the request. If the server
+   chooses to close the connection immediately after sending the
+   response, it &SHOULD; send a Connection header including the
+   connection-token close.
+</t>
+<t>
+   An HTTP/1.1 client &MAY; expect a connection to remain open, but would
+   decide to keep it open based on whether the response from a server
+   contains a Connection header with the connection-token close. In case
+   the client does not want to maintain a connection for more than that
+   request, it &SHOULD; send a Connection header including the
+   connection-token close.
+</t>
+<t>
+   If either the client or the server sends the close token in the
+   Connection header, that request becomes the last one for the
+   connection.
+</t>
+<t>
+   Clients and servers &SHOULD-NOT;  assume that a persistent connection is
+   maintained for HTTP versions less than 1.1 unless it is explicitly
+   signaled. See <xref target="compatibility.with.http.1.0.persistent.connections"/> for more information on backward
+   compatibility with HTTP/1.0 clients.
+</t>
+<t>
+   In order to remain persistent, all messages on the connection &MUST;
+   have a self-defined message length (i.e., one not defined by closure
+   of the connection), as described in <xref target="message.length"/>.
+</t>
+</section>
+
+<section title="Pipelining" anchor="pipelining">
+<t>
+   A client that supports persistent connections &MAY; "pipeline" its
+   requests (i.e., send multiple requests without waiting for each
+   response). A server &MUST; send its responses to those requests in the
+   same order that the requests were received.
+</t>
+<t>
+   Clients which assume persistent connections and pipeline immediately
+   after connection establishment &SHOULD; be prepared to retry their
+   connection if the first pipelined attempt fails. If a client does
+   such a retry, it &MUST-NOT; pipeline before it knows the connection is
+   persistent. Clients &MUST; also be prepared to resend their requests if
+   the server closes the connection before sending all of the
+   corresponding responses.
+</t>
+<t>
+   Clients &SHOULD-NOT;  pipeline requests using non-idempotent methods or
+   non-idempotent sequences of methods (see &idempotent-methods;). Otherwise, a
+   premature termination of the transport connection could lead to
+   indeterminate results. A client wishing to send a non-idempotent
+   request &SHOULD; wait to send that request until it has received the
+   response status for the previous request.
+</t>
+</section>
+</section>
+
+<section title="Proxy Servers" anchor="persistent.proxy">
+<t>
+   It is especially important that proxies correctly implement the
+   properties of the Connection header field as specified in <xref target="header.connection"/>.
+</t>
+<t>
+   The proxy server &MUST; signal persistent connections separately with
+   its clients and the origin servers (or other proxy servers) that it
+   connects to. Each persistent connection applies to only one transport
+   link.
+</t>
+<t>
+   A proxy server &MUST-NOT; establish a HTTP/1.1 persistent connection
+   with an HTTP/1.0 client (but see RFC 2068 <xref target="RFC2068"/> for information and
+   discussion of the problems with the Keep-Alive header implemented by
+   many HTTP/1.0 clients).
+</t>
+</section>
+
+<section title="Practical Considerations" anchor="persistent.practical">
+<t>
+   Servers will usually have some time-out value beyond which they will
+   no longer maintain an inactive connection. Proxy servers might make
+   this a higher value since it is likely that the client will be making
+   more connections through the same server. The use of persistent
+   connections places no requirements on the length (or existence) of
+   this time-out for either the client or the server.
+</t>
+<t>
+   When a client or server wishes to time-out it &SHOULD; issue a graceful
+   close on the transport connection. Clients and servers &SHOULD; both
+   constantly watch for the other side of the transport close, and
+   respond to it as appropriate. If a client or server does not detect
+   the other side's close promptly it could cause unnecessary resource
+   drain on the network.
+</t>
+<t>
+   A client, server, or proxy &MAY; close the transport connection at any
+   time. For example, a client might have started to send a new request
+   at the same time that the server has decided to close the "idle"
+   connection. From the server's point of view, the connection is being
+   closed while it was idle, but from the client's point of view, a
+   request is in progress.
+</t>
+<t>
+   This means that clients, servers, and proxies &MUST; be able to recover
+   from asynchronous close events. Client software &SHOULD; reopen the
+   transport connection and retransmit the aborted sequence of requests
+   without user interaction so long as the request sequence is
+   idempotent (see &idempotent-methods;). Non-idempotent methods or sequences
+   &MUST-NOT; be automatically retried, although user agents &MAY; offer a
+   human operator the choice of retrying the request(s). Confirmation by
+   user-agent software with semantic understanding of the application
+   &MAY; substitute for user confirmation. The automatic retry &SHOULD-NOT; 
+   be repeated if the second sequence of requests fails.
+</t>
+<t>
+   Servers &SHOULD; always respond to at least one request per connection,
+   if at all possible. Servers &SHOULD-NOT;  close a connection in the
+   middle of transmitting a response, unless a network or client failure
+   is suspected.
+</t>
+<t>
+   Clients that use persistent connections &SHOULD; limit the number of
+   simultaneous connections that they maintain to a given server. A
+   single-user client &SHOULD-NOT; maintain more than 2 connections with
+   any server or proxy. A proxy &SHOULD; use up to 2*N connections to
+   another server or proxy, where N is the number of simultaneously
+   active users. These guidelines are intended to improve HTTP response
+   times and avoid congestion.
+</t>
+</section>
+</section>
+
+<section title="Message Transmission Requirements" anchor="message.transmission.requirements">
+
+<section title="Persistent Connections and Flow Control" anchor="persistent.flow">
+<t>
+   HTTP/1.1 servers &SHOULD; maintain persistent connections and use TCP's
+   flow control mechanisms to resolve temporary overloads, rather than
+   terminating connections with the expectation that clients will retry.
+   The latter technique can exacerbate network congestion.
+</t>
+</section>
+
+<section title="Monitoring Connections for Error Status Messages" anchor="persistent.monitor">
+<t>
+   An HTTP/1.1 (or later) client sending a message-body &SHOULD; monitor
+   the network connection for an error status while it is transmitting
+   the request. If the client sees an error status, it &SHOULD;
+   immediately cease transmitting the body. If the body is being sent
+   using a "chunked" encoding (<xref target="transfer.codings"/>), a zero length chunk and
+   empty trailer &MAY; be used to prematurely mark the end of the message.
+   If the body was preceded by a Content-Length header, the client &MUST;
+   close the connection.
+</t>
+</section>
+
+<section title="Use of the 100 (Continue) Status" anchor="use.of.the.100.status">
+<t>
+   The purpose of the 100 (Continue) status (see &status-100;) is to
+   allow a client that is sending a request message with a request body
+   to determine if the origin server is willing to accept the request
+   (based on the request headers) before the client sends the request
+   body. In some cases, it might either be inappropriate or highly
+   inefficient for the client to send the body if the server will reject
+   the message without looking at the body.
+</t>
+<t>
+   Requirements for HTTP/1.1 clients:
+  <list style="symbols">
+    <t>
+        If a client will wait for a 100 (Continue) response before
+        sending the request body, it &MUST; send an Expect request-header
+        field (&header-expect;) with the "100-continue" expectation.
+    </t>
+    <t>
+        A client &MUST-NOT; send an Expect request-header field (&header-expect;)
+        with the "100-continue" expectation if it does not intend
+        to send a request body.
+    </t>
+  </list>
+</t>
+<t>
+   Because of the presence of older implementations, the protocol allows
+   ambiguous situations in which a client may send "Expect: 100-continue"
+   without receiving either a 417 (Expectation Failed) status
+   or a 100 (Continue) status. Therefore, when a client sends this
+   header field to an origin server (possibly via a proxy) from which it
+   has never seen a 100 (Continue) status, the client &SHOULD-NOT;  wait
+   for an indefinite period before sending the request body.
+</t>
+<t>
+   Requirements for HTTP/1.1 origin servers:
+  <list style="symbols">
+    <t> Upon receiving a request which includes an Expect request-header
+        field with the "100-continue" expectation, an origin server &MUST;
+        either respond with 100 (Continue) status and continue to read
+        from the input stream, or respond with a final status code. The

[... 2079 lines stripped ...]


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@labs.apache.org
For additional commands, e-mail: commits-help@labs.apache.org