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 ------------------------>
+ UA -------------------v------------------- O
+ <----------------------- 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 -------------------------------------->
+ UA -----v----- A -----v----- B -----v----- C -----v----- O
+ <------------------------------------- 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 ---------->
+ UA -----v----- A -----v----- B - - - - - - C - - - - - - O
+ <--------- 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 "<" and ">") 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 "<n>*<m>element" indicating at least <n> and at most
+ <m> 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: "<n>(element)" is equivalent to
+ "<n>*<n>(element)"; that is, exactly <n> 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 "<n>#<m>element" indicating at least
+ <n> and at most <m> 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 = <any 8-bit sequence of data>
+ CHAR = <any US-ASCII character (octets 0 - 127)>
+ UPALPHA = <any US-ASCII uppercase letter "A".."Z">
+ LOALPHA = <any US-ASCII lowercase letter "a".."z">
+ ALPHA = UPALPHA | LOALPHA
+ DIGIT = <any US-ASCII digit "0".."9">
+ CTL = <any US-ASCII control character
+ (octets 0 - 31) and DEL (127)>
+ CR = <US-ASCII CR, carriage return (13)>
+ LF = <US-ASCII LF, linefeed (10)>
+ SP = <US-ASCII SP, space (32)>
+ HT = <US-ASCII HT, horizontal-tab (9)>
+ <"> = <US-ASCII double-quote mark (34)>
+</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 = <any OCTET except CTLs,
+ but including LWS>
+</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*<any CHAR except CTLs or separators>
+ separators = "(" | ")" | "<" | ">" | "@"
+ | "," | ";" | ":" | "\" | <">
+ | "/" | "[" | "]" | "?" | "="
+ | "{" | "}" | 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 = <any TEXT excluding "(" and ")">
+</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 = ( <"> *(qdtext | quoted-pair ) <"> )
+ qdtext = <any TEXT except <">>
+</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 "<major>.<minor>" 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 <minor> 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 <major> 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 > 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 = <the OCTETs making up the field-value
+ and consisting of either *TEXT or combinations
+ of token, separators, and quoted-string>
+</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
+ | <entity-body encoded as per Transfer-Encoding>
+</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 = *<TEXT, excluding CR, LF>
+</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