HTTP/1.1, part 1: URIs, Connections, and Message Parsing

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 [RFC2119].¶

This specification uses the Augmented Backus-Naur Form (ABNF) notation of [RFC5234] with the list rule extension defined in Section 3.2.5. Appendix B shows the collected ABNF with the list rule expanded.¶

The following core rules are included by reference, as defined in [RFC5234], Appendix B.1: ALPHA (letters), CR (carriage return), CRLF (CR LF), CTL (controls), DIGIT (decimal 0-9), DQUOTE (double quote), HEXDIG (hexadecimal 0-9/A-F/a-f), HTAB (horizontal tab), LF (line feed), OCTET (any 8-bit sequence of data), SP (space), and VCHAR (any visible [USASCII] character).¶

As a convention, ABNF rule names prefixed with "obs-" denote "obsolete" grammar rules that appear for historical reasons.¶

HTTP is a stateless request/response protocol that operates by exchanging messages (Section 3) across a reliable transport or session-layer "connection". An HTTP "client" is a program that establishes a connection to a server for the purpose of sending one or more HTTP requests. An HTTP "server" is a program that accepts connections in order to service HTTP requests by sending HTTP responses.¶

Note that the terms client and server refer only to the roles that these programs perform for a particular connection. The same program might act as a client on some connections and a server on others. We use the term "user agent" to refer to the program that initiates a request, such as a WWW browser, editor, or spider (web-traversing robot), and the term "origin server" to refer to the program that can originate authoritative responses to a request. For general requirements, we use the term "sender" to refer to whichever component sent a given message and the term "recipient" to refer to any component that receives the message.¶

Most HTTP communication consists of a retrieval request (GET) for a representation of some resource identified by a URI. In the simplest case, this might be accomplished via a single bidirectional connection (===) between the user agent (UA) and the origin server (O).¶

A client sends an HTTP request to the server in the form of a request message, beginning with a request-line that includes a method, URI, and protocol version (Section 3.1.1), followed by MIME-like header fields containing request modifiers, client information, and representation metadata (Section 3.2), an empty line to indicate the end of the header section, and finally a message body containing the payload body (if any, Section 3.3).¶

A server responds to the client's request by sending one or more HTTP response messages, each beginning with a status line that includes the protocol version, a success or error code, and textual reason phrase (Section 3.1.2), possibly followed by MIME-like header fields containing server information, resource metadata, and representation metadata (Section 3.2), an empty line to indicate the end of the header section, and finally a message body containing the payload body (if any, Section 3.3).¶

client request:

GET /hello.txt HTTP/1.1
User-Agent: curl/7.16.3 libcurl/7.16.3 OpenSSL/0.9.7l zlib/1.2.3
Host: www.example.com
Accept: */*

server response:

HTTP/1.1 200 OK
Date: Mon, 27 Jul 2009 12:28:53 GMT
Server: Apache
Last-Modified: Wed, 22 Jul 2009 19:15:56 GMT
ETag: "34aa387-d-1568eb00"
Accept-Ranges: bytes
Content-Length: 14
Vary: Accept-Encoding
Content-Type: text/plain

Hello World!

HTTP messaging is independent of the underlying transport or session-layer connection protocol(s). HTTP only presumes a reliable transport with in-order delivery of requests and the corresponding in-order delivery of responses. The mapping of HTTP request and response structures onto the data units of the underlying transport protocol is outside the scope of this specification.¶

The specific connection protocols to be used for an interaction are determined by client configuration and the target URI (Section 5.1). For example, the "http" URI scheme (Section 2.7.1) indicates a default connection of TCP over IP, with a default TCP port of 80, but the client might be configured to use a proxy via some other connection port or protocol instead of using the defaults.¶

A connection might be used for multiple HTTP request/response exchanges, as defined in Section 6.3.¶

HTTP enables the use of intermediaries to satisfy requests through a chain of connections. There are three common forms of HTTP intermediary: proxy, gateway, and tunnel. In some cases, a single intermediary might act as an origin server, proxy, gateway, or tunnel, switching behavior based on the nature of each request.¶

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. Some HTTP communication options might 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 might be engaged in multiple, simultaneous communications. For example, B might 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.¶

We use the terms "upstream" and "downstream" to describe various requirements in relation to the directional flow of a message: all messages flow from upstream to downstream. Likewise, we use the terms inbound and outbound to refer to directions in relation to the request path: "inbound" means toward the origin server and "outbound" means toward the user agent.¶

A "proxy" is a message forwarding agent that is selected by the client, usually via local configuration rules, to receive requests for some type(s) of absolute URI and attempt to satisfy those requests via translation through the HTTP interface. Some translations are minimal, such as for proxy requests for "http" URIs, whereas other requests might require translation to and from entirely different application-layer protocols. Proxies are often used to group an organization's HTTP requests through a common intermediary for the sake of security, annotation services, or shared caching.¶

An HTTP-to-HTTP proxy is called a "transforming proxy" if it is designed or configured to modify request or response messages in a semantically meaningful way (i.e., modifications, beyond those required by normal HTTP processing, that change the message in a way that would be significant to the original sender or potentially significant to downstream recipients). For example, a transforming proxy might be acting as a shared annotation server (modifying responses to include references to a local annotation database), a malware filter, a format transcoder, or an intranet-to-Internet privacy filter. Such transformations are presumed to be desired by the client (or client organization) that selected the proxy and are beyond the scope of this specification. However, when a proxy is not intended to transform a given message, we use the term "non-transforming proxy" to target requirements that preserve HTTP message semantics. See Section 7.2.4 of [Part2] and Section 3.6 of [Part6] for status and warning codes related to transformations.¶

A "gateway" (a.k.a., "reverse proxy") is a receiving agent that acts as a layer above some other server(s) and translates the received requests to the underlying server's protocol. Gateways are often used to encapsulate legacy or untrusted information services, to improve server performance through "accelerator" caching, and to enable partitioning or load-balancing of HTTP services across multiple machines.¶

A gateway behaves as an origin server on its outbound connection and as a user agent on its inbound connection. All HTTP requirements applicable to an origin server also apply to the outbound communication of a gateway. A gateway communicates with inbound servers using any protocol that it desires, including private extensions to HTTP that are outside the scope of this specification. However, an HTTP-to-HTTP gateway that wishes to interoperate with third-party HTTP servers MUST conform to HTTP user agent requirements on the gateway's inbound connection and MUST implement the Connection (Section 6.1) and Via (Section 6.2) header fields for both connections.¶

A "tunnel" acts as a blind relay between two connections without changing the messages. Once active, a tunnel is not considered a party to the HTTP communication, though the tunnel might have been initiated by an HTTP request. A tunnel ceases to exist when both ends of the relayed connection are closed. Tunnels are used to extend a virtual connection through an intermediary, such as when transport-layer security is used to establish private communication through a shared firewall proxy.¶

In addition, there may exist network intermediaries that are not considered part of the HTTP communication but nevertheless act as filters or redirecting agents (usually violating HTTP semantics, causing security problems, and otherwise making a mess of things). Such a network intermediary, often referred to as an "interception proxy" [RFC3040], "transparent proxy" [RFC1919], or "captive portal", differs from an HTTP proxy because it has not been selected by the client. Instead, the network intermediary redirects outgoing TCP port 80 packets (and occasionally other common port traffic) to an internal HTTP server. Interception proxies are commonly found on public network access points, as a means of enforcing account subscription prior to allowing use of non-local Internet services, and within corporate firewalls to enforce network usage policies. They are indistinguishable from a man-in-the-middle attack.¶

HTTP is defined as a stateless protocol, meaning that each request message can be understood in isolation. Many implementations depend on HTTP's stateless design in order to reuse proxied connections or dynamically load balance requests across multiple servers. Hence, servers MUST NOT assume that two requests on the same connection are from the same user agent unless the connection is secured and specific to that agent. Some non-standard HTTP extensions (e.g., [RFC4559]) have been known to violate this requirement, resulting in security and interoperability problems.¶

A "cache" is a local store of previous 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 employ a cache, though a cache cannot be used by a server while it is acting as a tunnel.¶

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.¶

A response is "cacheable" if a cache is allowed to store a copy of the response message for use in answering subsequent requests. Even when a response is cacheable, there might be additional constraints placed by the client or by the origin server on when that cached response can be used for a particular request. HTTP requirements for cache behavior and cacheable responses are defined in Section 2 of [Part6].¶

There are a wide variety of architectures and configurations of caches and proxies deployed across the World Wide Web and inside large organizations. 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 optical media, and so on.¶

This specification targets conformance criteria according to the role of a participant in HTTP communication. Hence, HTTP requirements are placed on senders, recipients, clients, servers, user agents, intermediaries, origin servers, proxies, gateways, or caches, depending on what behavior is being constrained by the requirement.¶

An implementation is considered conformant if it complies with all of the requirements associated with the roles it partakes in HTTP.¶

Senders MUST NOT generate protocol elements that do not match the grammar defined by the ABNF rules for those protocol elements.¶

Unless otherwise noted, recipients MAY attempt to recover a usable protocol element from an invalid construct. HTTP does not define specific error handling mechanisms except when they have a direct impact on security, since different applications of the protocol require different error handling strategies. For example, a Web browser might wish to transparently recover from a response where the Location header field doesn't parse according to the ABNF, whereas a systems control client might consider any form of error recovery to be dangerous.¶

HTTP uses a "<major>.<minor>" numbering scheme to indicate versions of the protocol. This specification defines version "1.1". The protocol version as a whole indicates the sender's conformance with the set of requirements laid out in that version's corresponding specification of HTTP.¶

The version of an HTTP message is indicated by an HTTP-version field in the first line of the message. HTTP-version is case-sensitive.¶

The HTTP version number consists of two decimal digits separated by a "." (period or decimal point). The first digit ("major version") indicates the HTTP messaging syntax, whereas the second digit ("minor version") indicates the highest minor version to which the sender is conformant and able to understand for future communication. The minor version advertises the sender's communication capabilities even when the sender is only using a backwards-compatible subset of the protocol, thereby letting the recipient know that more advanced features can be used in response (by servers) or in future requests (by clients).¶

When an HTTP/1.1 message is sent to an HTTP/1.0 recipient [RFC1945] or a recipient whose version is unknown, the HTTP/1.1 message is constructed such that it can be interpreted as a valid HTTP/1.0 message if all of the newer features are ignored. This specification places recipient-version requirements on some new features so that a conformant sender will only use compatible features until it has determined, through configuration or the receipt of a message, that the recipient supports HTTP/1.1.¶

The interpretation of a header field does not change between minor versions of the same major HTTP version, though the default behavior of a recipient in the absence of such a field can change. Unless specified otherwise, header fields defined in HTTP/1.1 are defined for all versions of HTTP/1.x. In particular, the Host and Connection header fields ought to be implemented by all HTTP/1.x implementations whether or not they advertise conformance with HTTP/1.1.¶

New header fields can be defined such that, when they are understood by a recipient, they might override or enhance the interpretation of previously defined header fields. When an implementation receives an unrecognized header field, the recipient MUST ignore that header field for local processing regardless of the message's HTTP version. An unrecognized header field received by a proxy MUST be forwarded downstream unless the header field's field-name is listed in the message's Connection header-field (see Section 6.1). These requirements allow HTTP's functionality to be enhanced without requiring prior update of deployed intermediaries.¶

Intermediaries that process HTTP messages (i.e., all intermediaries other than those acting as tunnels) MUST send their own HTTP-version in forwarded messages. In other words, they MUST NOT blindly forward the first line of an HTTP message without ensuring that the protocol version in that message matches a version to which that intermediary is conformant for both the receiving and sending of messages. Forwarding an HTTP message without rewriting the HTTP-version might result in communication errors when downstream recipients use the message sender's version to determine what features are safe to use for later communication with that sender.¶

An HTTP client SHOULD send a request version equal to the highest version to which the client is conformant and whose major version is no higher than the highest version supported by the server, if this is known. An HTTP client MUST NOT send a version to which it is not conformant.¶

An HTTP client MAY send a lower request version if it is known that the server incorrectly implements the HTTP specification, but only after the client has attempted at least one normal request and determined from the response status or header fields (e.g., Server) that the server improperly handles higher request versions.¶

An HTTP server SHOULD send a response version equal to the highest version to which the server is conformant and whose major version is less than or equal to the one received in the request. An HTTP server MUST NOT send a version to which it is not conformant. A server MAY send a 505 (HTTP Version Not Supported) response if it cannot send a response using the major version used in the client's request.¶

An HTTP server MAY send an HTTP/1.0 response to an HTTP/1.0 request if it is known or suspected that the client incorrectly implements the HTTP specification and is incapable of correctly processing later version responses, such as when a client fails to parse the version number correctly or when an intermediary is known to blindly forward the HTTP-version even when it doesn't conform to the given minor version of the protocol. Such protocol downgrades SHOULD NOT be performed unless triggered by specific client attributes, such as when one or more of the request header fields (e.g., User-Agent) uniquely match the values sent by a client known to be in error.¶

The intention of HTTP's versioning design is that the major number will only be incremented if an incompatible message syntax is introduced, and that the minor number will only be incremented when changes made to the protocol have the effect of adding to the message semantics or implying additional capabilities of the sender. However, the minor version was not incremented for the changes introduced between [RFC2068] and [RFC2616], and this revision is specifically avoiding any such changes to the protocol.¶

Uniform Resource Identifiers (URIs) [RFC3986] are used throughout HTTP as the means for identifying resources. URI references are used to target requests, indicate redirects, and define relationships. HTTP does not limit what a resource might be; it merely defines an interface that can be used to interact with a resource via HTTP. More information on the scope of URIs and resources can be found in [RFC3986].¶

This specification adopts the definitions of "URI-reference", "absolute-URI", "relative-part", "port", "host", "path-abempty", "path-absolute", "query", and "authority" from the URI generic syntax [RFC3986]. In addition, we define a partial-URI rule for protocol elements that allow a relative URI but not a fragment.¶

Each protocol element in HTTP that allows a URI reference will indicate in its ABNF production whether the element allows any form of reference (URI-reference), only a URI in absolute form (absolute-URI), only the path and optional query components, or some combination of the above. Unless otherwise indicated, URI references are parsed relative to the effective request URI (Section 5.5).¶

An HTTP message can either be a request from client to server or a response from server to client. Syntactically, the two types of message differ only in the start-line, which is either a request-line (for requests) or a status-line (for responses), and in the algorithm for determining the length of the message body (Section 3.3). In theory, a client could receive requests and a server could receive responses, distinguishing them by their different start-line formats, but in practice servers are implemented to only expect a request (a response is interpreted as an unknown or invalid request method) and clients are implemented to only expect a response.¶

Implementations MUST NOT send whitespace between the start-line and the first header field. The presence of such whitespace in a request might be an attempt to trick a server into ignoring that field or processing the line after it as a new request, either of which might result in a security vulnerability if other implementations within the request chain interpret the same message differently. Likewise, the presence of such whitespace in a response might be ignored by some clients or cause others to cease parsing.¶

Each HTTP header field consists of a case-insensitive field name followed by a colon (":"), optional whitespace, and the field value.¶

The field-name token labels the corresponding field-value as having the semantics defined by that header field. For example, the Date header field is defined in Section 10.2 of [Part2] as containing the origination timestamp for the message in which it appears.¶

HTTP header fields are fully extensible: there is no limit on the introduction of new field names, each presumably defining new semantics, or on the number of header fields used in a given message. Existing fields are defined in each part of this specification and in many other specifications outside the standards process. New header fields can be introduced without changing the protocol version if their defined semantics allow them to be safely ignored by recipients that do not recognize them.¶

New HTTP header fields SHOULD be registered with IANA according to the procedures in Section 3.1 of [Part2]. Unrecognized header fields MUST be forwarded by a proxy unless the field-name is listed in the Connection header field (Section 6.1) or the proxy is specifically configured to block or otherwise transform such fields. Unrecognized header fields SHOULD be ignored by other recipients.¶

The order in which header fields with differing field names are received is not significant. However, it is "good practice" to send header fields that contain control data first, such as Host on requests and Date on responses, so that implementations can decide when not to handle a message as early as possible. A server MUST wait until the entire header section is received before interpreting a request message, since later header fields might include conditionals, authentication credentials, or deliberately misleading duplicate header fields that would impact request processing.¶

Multiple header fields with the same field name MUST NOT be sent in a message unless the entire field value for that header field is defined as a comma-separated list [i.e., #(values)]. Multiple header fields with the same field name can be combined into one "field-name: field-value" pair, without changing the semantics of the message, by appending each subsequent field value to the combined field value in order, 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; a proxy MUST NOT change the order of these field values when forwarding a message.¶

The message body (if any) of an HTTP message is used to carry the payload body of that request or response. The message body is identical to the payload body unless a transfer coding has been applied, as described in Section 3.3.1.¶

The rules for when a message body is allowed in a message differ for requests and responses.¶

The presence of a message body in a request is signaled by a a Content-Length or Transfer-Encoding header field. Request message framing is independent of method semantics, even if the method does not define any use for a message body.¶

The presence of a message body in a response depends on both the request method to which it is responding and the response status code (Paragraph 2). Responses to the HEAD request method never include a message body because the associated response header fields (e.g., Transfer-Encoding, Content-Length, etc.) only indicate what their values would have been if the request method had been GET. Successful (2xx) responses to CONNECT switch to tunnel mode instead of having a message body. 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 the body MAY be of zero length.¶

Request messages that are prematurely terminated, possibly due to a cancelled connection or a server-imposed time-out exception, MUST result in closure of the connection; sending an HTTP/1.1 error response prior to closing the connection is OPTIONAL.¶

Response messages that are prematurely terminated, usually by closure of the connection prior to receiving the expected number of octets or by failure to decode a transfer-encoded message body, MUST be recorded as incomplete. A response that terminates in the middle of the header block (before the empty line is received) cannot be assumed to convey the full semantics of the response and MUST be treated as an error.¶

A message body that uses the chunked transfer encoding is incomplete if the zero-sized chunk that terminates the encoding has not been received. A message that uses a valid Content-Length is incomplete if the size of the message body received (in octets) is less than the value given by Content-Length. A response that has neither chunked transfer encoding nor Content-Length is terminated by closure of the connection, and thus is considered complete regardless of the number of message body octets received, provided that the header block was received intact.¶

A user agent MUST NOT render an incomplete response message body as if it were complete (i.e., some indication must be given to the user that an error occurred). Cache requirements for incomplete responses are defined in Section 2.1 of [Part6].¶

A server MUST read the entire request message body or close the connection after sending its response, since otherwise the remaining data on a persistent connection would be misinterpreted as the next request. Likewise, a client MUST read the entire response message body if it intends to reuse the same connection for a subsequent request. Pipelining multiple requests on a connection is described in Section 6.3.2.2.¶

Older HTTP/1.0 client implementations might send an extra CRLF after a POST request as a lame workaround for some early server applications that failed to read message body content that was not terminated by a line-ending. An HTTP/1.1 client MUST NOT preface or follow a request with an extra CRLF. If terminating the request message body with a line-ending is desired, then the client MUST include the terminating CRLF octets as part of the message body length.¶

In the interest of robustness, servers SHOULD ignore at least one empty line 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. Likewise, although the line terminator for the start-line and header fields is the sequence CRLF, we recommend that recipients recognize a single LF as a line terminator and ignore any CR.¶

When a server listening only for HTTP request messages, or processing what appears from the start-line to be an HTTP request message, receives a sequence of octets that does not match the HTTP-message grammar aside from the robustness exceptions listed above, the server MUST respond with an HTTP/1.1 400 (Bad Request) response.¶

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 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.¶

The chunk-size field is a string of hex digits indicating the size of the chunk-data in octets. The chunked encoding is ended by any chunk whose size is zero, followed by the trailer, which is terminated by an empty line.¶

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 Section 4.4).¶

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: ¶

1. the request included a TE header field that indicates "trailers" is acceptable in the transfer-coding of the response, as described in Section 4.3; or,
2. the trailer fields consist entirely of optional metadata, and the recipient could use the message (in a manner acceptable to the server where the field originated) without receiving it. In other words, the server that generated the header (often but not always the origin server) is willing to accept the possibility that the trailer fields might be silently discarded along the path to the client.

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 conformance with the protocol would have necessitated a possibly infinite buffer on the proxy.¶

All HTTP/1.1 applications MUST be able to receive and decode the "chunked" transfer-coding and MUST ignore chunk-ext extensions they do not understand.¶

Use of chunk-ext extensions by senders is deprecated; they SHOULD NOT be sent and definition of new chunk-extensions is discouraged.¶

The codings defined below can be used to compress the payload of a message.¶

The "TE" header field indicates what extension transfer-codings the client is willing to accept in the response, and whether or not it is willing to accept trailer fields in a chunked transfer-coding.¶

Its value consists of the keyword "trailers" and/or a comma-separated list of extension transfer-coding names with optional accept parameters (as described in Section 4).¶

The presence of the keyword "trailers" indicates that the client is willing to accept trailer fields in a chunked transfer-coding, as defined in Section 4.1. This keyword is reserved for use with transfer-coding values even though it does not itself represent a transfer-coding.¶

The TE header field only applies to the immediate connection. Therefore, the keyword MUST be supplied within a Connection header field (Section 6.1) whenever TE is present in an HTTP/1.1 message.¶

A server tests whether a transfer-coding is acceptable, according to a TE field, using these rules: ¶

1. The "chunked" transfer-coding is always acceptable. If the keyword "trailers" is listed, the client indicates that it is willing to accept trailer fields in the chunked response on behalf of itself and any downstream clients. The implication is that, if given, the client is stating that either all downstream clients are willing to accept trailer fields in the forwarded response, or that it will attempt to buffer the response on behalf of downstream recipients.

   Note: HTTP/1.1 does not define any means to limit the size of a chunked response such that a client can be assured of buffering the entire response.

2. If the transfer-coding being tested is one of the transfer-codings listed in the TE field, then it is acceptable unless it is accompanied by a qvalue of 0. (As defined in Section 4.3.1, a qvalue of 0 means "not acceptable".)

3. If multiple transfer-codings are acceptable, then the acceptable transfer-coding with the highest non-zero qvalue is preferred. The "chunked" transfer-coding always has a qvalue of 1.

If the TE field-value is empty or if no TE field is present, the only acceptable transfer-coding is "chunked". A message with no transfer-coding is always acceptable.¶

The "Trailer" header field indicates that the given set of header fields is present in the trailer of a message encoded with chunked transfer-coding.¶

An HTTP/1.1 message SHOULD include a Trailer header field in a message using chunked transfer-coding with a non-empty trailer. Doing so allows the recipient to know which header fields to expect in the trailer.¶

If no Trailer header field is present, the trailer SHOULD NOT include any header fields. See Section 4.1 for restrictions on the use of trailer fields in a "chunked" transfer-coding.¶

Message header fields listed in the Trailer header field MUST NOT include the following header fields: ¶

• Transfer-Encoding
• Content-Length
• Trailer

HTTP is used in a wide variety of applications, ranging from general-purpose computers to home appliances. In some cases, communication options are hard-coded in a client's configuration. However, most HTTP clients rely on the same resource identification mechanism and configuration techniques as general-purpose Web browsers.¶

HTTP communication is initiated by a user agent for some purpose. The purpose is a combination of request semantics, which are defined in [Part2], and a target resource upon which to apply those semantics. A URI reference (Section 2.7) is typically used as an identifier for the "target resource", which a user agent would resolve to its absolute form in order to obtain the "target URI". The target URI excludes the reference's fragment identifier component, if any, since fragment identifiers are reserved for client-side processing ([RFC3986], Section 3.5).¶

HTTP intermediaries obtain the request semantics and target URI from the request-line of an incoming request message.¶

Once the target URI is determined, a client needs to decide whether a network request is necessary to accomplish the desired semantics and, if so, where that request is to be directed.¶

If the client has a response cache and the request semantics can be satisfied by a cache ([Part6]), then the request is usually directed to the cache first.¶

If the request is not satisfied by a cache, then a typical client will check its configuration to determine whether a proxy is to be used to satisfy the request. Proxy configuration is implementation-dependent, but is often based on URI prefix matching, selective authority matching, or both, and the proxy itself is usually identified by an "http" or "https" URI. If a proxy is applicable, the client connects inbound by establishing (or reusing) a connection to that proxy.¶

If no proxy is applicable, a typical client will invoke a handler routine, usually specific to the target URI's scheme, to connect directly to an authority for the target resource. How that is accomplished is dependent on the target URI scheme and defined by its associated specification, similar to how this specification defines origin server access for resolution of the "http" (Section 2.7.1) and "https" (Section 2.7.2) schemes.¶

Once an inbound connection is obtained (Section 6), the client sends an HTTP request message (Section 3) with a request-target derived from the target URI. There are four distinct formats for the request-target, depending on both the method being requested and whether the request is to a proxy.¶

The most common form of request-target is the origin-form. When making a request directly to an origin server, other than a CONNECT or server-wide OPTIONS request (as detailed below), a client MUST send only the absolute path and query components of the target URI as the request-target. If the target URI's path component is empty, then the client MUST send "/" as the path within the origin-form of request-target. A Host header field is also sent, as defined in Section 5.4, containing the target URI's authority component (excluding any userinfo).¶

For example, a client wishing to retrieve a representation of the resource identified as¶

followed by the remainder of the request message.¶

When making a request to a proxy, other than a CONNECT or server-wide OPTIONS request (as detailed below), a client MUST send the target URI in absolute-form as the request-target. The proxy is requested to either service that request from a valid cache, if possible, or make the same request on the client's behalf to either the next inbound proxy server or directly to the origin server indicated by the request-target. Requirements on such "forwarding" of messages are defined in Section 5.6.¶

To allow for transition to the absolute-form for all requests in some future version of HTTP, HTTP/1.1 servers MUST accept the absolute-form in requests, even though HTTP/1.1 clients will only send them in requests to proxies.¶

The authority-form of request-target is only used for CONNECT requests (Section 6.9 of [Part2]). When making a CONNECT request to establish a tunnel through one or more proxies, a client MUST send only the target URI's authority component (excluding any userinfo) as the request-target. For example,¶

The asterisk-form of request-target is only used for a server-wide OPTIONS request (Section 6.2 of [Part2]). When a client wishes to request OPTIONS for the server as a whole, as opposed to a specific named resource of that server, the client MUST send only "*" (%x2A) as the request-target. For example,¶

If a proxy receives an OPTIONS request with an absolute-form of request-target in which the URI has an empty path and no query component, then the last proxy on the request chain MUST send a request-target of "*" when it forwards the request to the indicated origin server.¶

For example, the request

OPTIONS http://www.example.org:8001 HTTP/1.1

would be forwarded by the final proxy as

OPTIONS * HTTP/1.1
Host: www.example.org:8001

after connecting to port 8001 of host "www.example.org".

The "Host" header field in a request provides the host and port information from the target URI, enabling the origin server to distinguish among resources while servicing requests for multiple host names on a single IP address. Since the Host field-value is critical information for handling a request, it SHOULD be sent as the first header field following the request-line.¶

A client MUST send a Host header field in all HTTP/1.1 request messages. If the target URI includes an authority component, then the Host field-value MUST be identical to that authority component after excluding any userinfo (Section 2.7.1). If the authority component is missing or undefined for the target URI, then the Host header field MUST be sent with an empty field-value.¶

The Host header field MUST be sent in an HTTP/1.1 request even if the request-target is in the absolute-form, since this allows the Host information to be forwarded through ancient HTTP/1.0 proxies that might not have implemented Host.¶

When an HTTP/1.1 proxy receives a request with an absolute-form of request-target, the proxy MUST ignore the received Host header field (if any) and instead replace it with the host information of the request-target. If the proxy forwards the request, it MUST generate a new Host field-value based on the received request-target rather than forward the received Host field-value.¶

Since the Host header field acts as an application-level routing mechanism, it is a frequent target for malware seeking to poison a shared cache or redirect a request to an unintended server. An interception proxy is particularly vulnerable if it relies on the Host field-value for redirecting requests to internal servers, or for use as a cache key in a shared cache, without first verifying that the intercepted connection is targeting a valid IP address for that host.¶

A server MUST respond with a 400 (Bad Request) status code to any HTTP/1.1 request message that lacks a Host header field and to any request message that contains more than one Host header field or a Host header field with an invalid field-value.¶

A server that receives an HTTP request message MUST reconstruct the user agent's original target URI, based on the pieces of information learned from the request-target, Host, and connection context, in order to identify the intended target resource and properly service the request. The URI derived from this reconstruction process is referred to as the "effective request URI".¶

For a user agent, the effective request URI is the target URI.¶

If the request-target is in absolute-form, then the effective request URI is the same as the request-target. Otherwise, the effective request URI is constructed as follows.¶

If the request is received over an SSL/TLS-secured TCP connection, then the effective request URI's scheme is "https"; otherwise, the scheme is "http".¶

If the request-target is in authority-form, then the effective request URI's authority component is the same as the request-target. Otherwise, if a Host header field is supplied with a non-empty field-value, then the authority component is the same as the Host field-value. Otherwise, the authority component is the concatenation of the default hostname configured for the server, a colon (":"), and the connection's incoming TCP port number in decimal form.¶

If the request-target is in authority-form or asterisk-form, then the effective request URI's combined path and query component is empty. Otherwise, the combined path and query component is the same as the request-target.¶

The components of the effective request URI, once determined as above, can be combined into absolute-URI form by concatenating the scheme, "://", authority, and combined path and query component.¶

Example 1: the following message received over an insecure TCP connection

GET /pub/WWW/TheProject.html HTTP/1.1
Host: www.example.org:8080

has an effective request URI of

http://www.example.org:8080/pub/WWW/TheProject.html

Example 2: the following message received over an SSL/TLS-secured TCP connection

OPTIONS * HTTP/1.1
Host: www.example.org

has an effective request URI of

https://www.example.org

An origin server that does not allow resources to differ by requested host MAY ignore the Host field-value and instead replace it with a configured server name when constructing the effective request URI.¶

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 guess the effective request URI's authority component.¶

As described in Section 2.3, intermediaries can serve a variety of roles in the processing of HTTP requests and responses. Some intermediaries are used to improve performance or availability. Others are used for access control or to filter content. Since an HTTP stream has characteristics similar to a pipe-and-filter architecture, there are no inherent limits to the extent an intermediary can enhance (or interfere) with either direction of the stream.¶

In order to avoid request loops, a proxy that forwards requests to other proxies MUST be able to recognize and exclude all of its own server names, including any aliases, local variations, or literal IP addresses.¶

If a proxy receives a request-target with a host name that is not a fully qualified domain name, it MAY add its domain to the host name it received when forwarding the request. A proxy MUST NOT change the host name if it is a fully qualified domain name.¶

A non-transforming proxy MUST NOT rewrite the "path-absolute" and "query" parts of the received request-target when forwarding it to the next inbound server, except as noted above to replace an empty path with "/" or "*".¶

Intermediaries that forward a message MUST implement the Connection header field as specified in Section 6.1.¶

HTTP does not include a request identifier for associating a given request message with its corresponding one or more response messages. Hence, it relies on the order of response arrival to correspond exactly to the order in which requests are made on the same connection. More than one response message per request only occurs when one or more informational responses (1xx, see Section 7.1 of [Part2]) precede a final response to the same request.¶

A client that uses persistent connections and sends more than one request per connection MUST maintain a list of outstanding requests in the order sent on that connection and MUST associate each received response message to the highest ordered request that has not yet received a final (non-1xx) response.¶

The "Connection" header field allows the sender to specify options that are desired only for that particular connection. Such connection options MUST be removed or replaced before the message can be forwarded downstream by a proxy or gateway. This mechanism also allows the sender to indicate which HTTP header fields used in the message are only intended for the immediate recipient ("hop-by-hop"), as opposed to all recipients on the chain ("end-to-end"), enabling the message to be self-descriptive and allowing future connection-specific extensions to be deployed in HTTP without fear that they will be blindly forwarded by previously deployed intermediaries.¶

A proxy or gateway MUST parse a received Connection header field before a message is forwarded and, for each connection-token in this field, remove any header field(s) from the message with the same name as the connection-token, and then remove the Connection header field itself or replace it with the sender's own connection options for the forwarded message.¶

A sender MUST NOT include field-names in the Connection header field-value for fields that are defined as expressing constraints for all recipients in the request or response chain, such as the Cache-Control header field (Section 3.2 of [Part6]).¶

The connection options do not have to correspond to a header field present in the message, since a connection-specific header field might not be needed if there are no parameters associated with that connection option. Recipients that trigger certain connection behavior based on the presence of connection options MUST do so based on the presence of the connection-token rather than only the presence of the optional header field. In other words, if the connection option is received as a header field but not indicated within the Connection field-value, then the recipient MUST ignore the connection-specific header field because it has likely been forwarded by an intermediary that is only partially conformant.¶

When defining new connection options, specifications ought to carefully consider existing deployed header fields and ensure that the new connection-token does not share the same name as an unrelated header field that might already be deployed. Defining a new connection-token essentially reserves that potential field-name for carrying additional information related to the connection option, since it would be unwise for senders to use that field-name for anything else.¶

HTTP/1.1 defines the "close" connection option for the sender to signal that the connection will be closed after completion of the response. For example,¶

in either the request or the response header fields indicates that the connection SHOULD NOT be considered "persistent" (Section 6.3) after the current request/response is complete.¶

An HTTP/1.1 client that does not support persistent connections MUST include the "close" connection option in every request message.¶

An HTTP/1.1 server that does not support persistent connections MUST include the "close" connection option in every response message that does not have a 1xx (Informational) status code.¶

The "Via" header field MUST be sent by a proxy or gateway to indicate the intermediate protocols and recipients between the user agent and the server on requests, and between the origin server and the client on responses. It is analogous to the "Received" field used by email systems (Section 3.6.7 of [RFC5322]) and is intended to be used for tracking message forwards, avoiding request loops, and identifying the protocol capabilities of all senders along the request/response chain.¶

The received-protocol indicates the protocol version of the message received by the server or client along each segment of the request/response chain. The received-protocol version is appended to the Via field value when the message is forwarded so that information about the protocol capabilities of upstream applications remains visible to all recipients.¶

The protocol-name is excluded if and only if it would be "HTTP". The received-by field is normally the host and optional port number of a recipient server or client that subsequently forwarded the message. However, if the real host is considered to be sensitive information, it MAY be replaced by a pseudonym. If the port is not given, it MAY be assumed to be the default port of the received-protocol.¶

Multiple Via field values represent each proxy or gateway that has forwarded the message. Each recipient MUST append its information such that the end result is ordered according to the sequence of forwarding applications.¶

Comments MAY be used in the Via header field to identify the software of each recipient, analogous to the User-Agent and Server header fields. However, all comments in the Via field are optional and MAY be removed by any recipient prior to forwarding the message.¶

A proxy or gateway used as a portal through a network firewall SHOULD NOT forward the names and ports of hosts within the firewall region unless it is explicitly enabled to do so. If not enabled, the received-by host of any host behind the firewall SHOULD be replaced by an appropriate pseudonym for that host.¶

For organizations that have strong privacy requirements for hiding internal structures, a proxy or gateway MAY combine an ordered subsequence of Via header field entries with identical received-protocol values into a single such entry. For example,¶

could be collapsed to¶

Senders SHOULD NOT combine multiple entries unless they are all under the same organizational control and the hosts have already been replaced by pseudonyms. Senders MUST NOT combine entries which have different received-protocol values.¶

The "Upgrade" header field allows the client to specify what additional communication protocols it would like to use, if the server chooses to switch protocols. Servers can use it to indicate what protocols they are willing to switch to.¶

For example,¶

The Upgrade header field is intended to provide a simple mechanism for transitioning from HTTP/1.1 to some other, incompatible protocol. It does so by allowing the client to advertise its desire to use another protocol, such as a later version of HTTP with a higher major version number, even though the current request has been made using HTTP/1.1. This eases the difficult transition between incompatible protocols by allowing the client to initiate a request in the more commonly supported protocol while indicating to the server that it would like to use a "better" protocol if available (where "better" is determined by the server, possibly according to the nature of the request method or target resource).¶

The Upgrade header field only applies to switching application-layer protocols upon the existing transport-layer connection. Upgrade cannot be used to insist on a protocol change; its acceptance and use by the server is optional. The capabilities and nature of the application-layer communication after the protocol change is entirely dependent upon the new protocol chosen, although the first action after changing the protocol MUST be a response to the initial HTTP request containing the Upgrade header field.¶

The Upgrade header field only applies to the immediate connection. Therefore, the upgrade keyword MUST be supplied within a Connection header field (Section 6.1) whenever Upgrade is present in an HTTP/1.1 message.¶

The Upgrade header field cannot be used to indicate a switch to a protocol on a different connection. For that purpose, it is more appropriate to use a 3xx redirection response (Section 7.3 of [Part2]).¶

Servers MUST include the "Upgrade" header field in 101 (Switching Protocols) responses to indicate which protocol(s) are being switched to, and MUST include it in 426 (Upgrade Required) responses to indicate acceptable protocols to upgrade to. Servers MAY include it in any other response to indicate that they are willing to upgrade to one of the specified protocols.¶

This specification only defines the protocol name "HTTP" for use by the family of Hypertext Transfer Protocols, as defined by the HTTP version rules of Section 2.6 and future updates to this specification. Additional tokens can be registered with IANA using the registration procedure defined in Section 7.6.¶

HTTP header fields are registered within the Message Header Field Registry [RFC3864] maintained by IANA at <http://www.iana.org/assignments/message-headers/message-header-index.html>.¶

Furthermore, the header field-name "Close" shall be registered as "reserved", since using that name as an HTTP header field might conflict with the "close" connection option of the "Connection" header field (Section 6.1).¶

The change controller is: "IETF (iesg@ietf.org) - Internet Engineering Task Force".¶

IANA maintains the registry of URI Schemes [RFC4395] at <http://www.iana.org/assignments/uri-schemes.html>.¶

This document serves as the specification for the Internet media types "message/http" and "application/http". The following is to be registered with IANA (see [RFC4288]).¶

The HTTP Transfer Coding Registry defines the name space for transfer coding names.¶

Registrations MUST include the following fields: ¶

• Name
• Description
• Pointer to specification text

Names of transfer codings MUST NOT overlap with names of content codings (Section 2.2 of [Part3]) unless the encoding transformation is identical, as it is the case for the compression codings defined in Section 4.2.¶

Values to be added to this name space require IETF Review (see Section 4.1 of [RFC5226]), and MUST conform to the purpose of transfer coding defined in this section.¶

The registry itself is maintained at <http://www.iana.org/assignments/http-parameters>.¶

The HTTP Upgrade Token Registry defines the name space for protocol-name tokens used to identify protocols in the Upgrade header field. Each registered protocol-name is associated with contact information and an optional set of specifications that details how the connection will be processed after it has been upgraded.¶

Registrations require IETF Review (see Section 4.1 of [RFC5226]) and are subject to the following rules: ¶

1. A protocol-name token, once registered, stays registered forever.
2. The registration MUST name a responsible party for the registration.
3. The registration MUST name a point of contact.
4. The registration MAY name a set of specifications associated with that token. Such specifications need not be publicly available.
5. The registration SHOULD name a set of expected "protocol-version" tokens associated with that token at the time of registration.
6. The responsible party MAY change the registration at any time. The IANA will keep a record of all such changes, and make them available upon request.
7. The IESG MAY reassign responsibility for a protocol token. This will normally only be used in the case when a responsible party cannot be contacted.

This registration procedure for HTTP Upgrade Tokens replaces that previously defined in Section 7.2 of [RFC2817].¶

The responsible party is: "IETF (iesg@ietf.org) - Internet Engineering Task Force".¶

HTTP clients are often privy to large amounts of personal information (e.g., the user's name, location, mail address, passwords, encryption keys, etc.), and SHOULD be very careful to prevent unintentional leakage of this information. We very strongly recommend that a convenient interface be provided for the user to control dissemination of such information, and that designers and implementors be particularly careful in this area. History shows that errors in this area often create serious security and/or privacy problems and generate highly adverse publicity for the implementor's company.¶

A server is in the position to save personal data about a user's requests which might identify their reading patterns or subjects of interest. In particular, log information gathered at an intermediary often contains a history of user agent interaction, across a multitude of sites, that can be traced to individual users.¶

HTTP log information is confidential in nature; its handling is often constrained by laws and regulations. Log information needs to be securely stored and appropriate guidelines followed for its analysis. Anonymization of personal information within individual entries helps, but is generally not sufficient to prevent real log traces from being re-identified based on correlation with other access characteristics. As such, access traces that are keyed to a specific client should not be published even if the key is pseudonymous.¶

To minimize the risk of theft or accidental publication, log information should be purged of personally identifiable information, including user identifiers, IP addresses, and user-provided query parameters, as soon as that information is no longer necessary to support operational needs for security, auditing, or fraud control.¶

Implementations of HTTP origin servers SHOULD be careful to restrict the documents returned by HTTP requests to be only those that were intended by the server administrators. If an HTTP server translates HTTP URIs directly into file system calls, the server MUST take special care not to serve files that were not intended to be delivered to HTTP clients. For example, UNIX, Microsoft Windows, and other operating systems use ".." as a path component to indicate a directory level above the current one. On such a system, an HTTP server MUST disallow any such construct in the request-target if it would otherwise allow access to a resource outside those intended to be accessible via the HTTP server. Similarly, files intended for reference only internally to the server (such as access control files, configuration files, and script code) MUST be protected from inappropriate retrieval, since they might contain sensitive information. Experience has shown that minor bugs in such HTTP server implementations have turned into security risks.¶

HTTP clients rely heavily on the Domain Name Service (DNS), and are thus generally prone to security attacks based on the deliberate misassociation of IP addresses and DNS names not protected by DNSSec. Clients need to be cautious in assuming the validity of an IP number/DNS name association unless the response is protected by DNSSec ([RFC4033]).¶

By their very nature, HTTP intermediaries are men-in-the-middle, and represent an opportunity for man-in-the-middle attacks. Compromise of the systems on which the intermediaries run can result in serious security and privacy problems. Intermediaries have access to security-related information, personal information about individual users and organizations, and proprietary information belonging to users and content providers. A compromised intermediary, or an intermediary implemented or configured without regard to security and privacy considerations, might be used in the commission of a wide range of potential attacks.¶

Intermediaries that contain a shared cache are especially vulnerable to cache poisoning attacks.¶

Implementors need to consider the privacy and security implications of their design and coding decisions, and of the configuration options they provide to operators (especially the default configuration).¶

Users need to be aware that intermediaries are no more trustworthy than the people who run them; HTTP itself cannot solve this problem.¶

The judicious use of cryptography, when appropriate, might suffice to protect against a broad range of security and privacy attacks. Such cryptography is beyond the scope of the HTTP/1.1 specification.¶

Because HTTP uses mostly textual, character-delimited fields, attackers can overflow buffers in implementations, and/or perform a Denial of Service against implementations that accept fields with unlimited lengths.¶

To promote interoperability, this specification makes specific recommendations for minimum size limits on request-line (Section 3.1.1) and blocks of header fields (Section 3.2). These are minimum recommendations, chosen to be supportable even by implementations with limited resources; it is expected that most implementations will choose substantially higher limits.¶

This specification also provides a way for servers to reject messages that have request-targets that are too long (Section 7.4.12 of [Part2]) or request entities that are too large (Section 7.4 of [Part2]).¶

Other fields (including but not limited to request methods, response status phrases, header field-names, and body chunks) SHOULD be limited by implementations carefully, so as to not impede interoperability.¶

10.1. Normative References

[ISO-8859-1]

International Organization for Standardization, “Information technology -- 8-bit single-byte coded graphic character sets -- Part 1: Latin alphabet No. 1”, ISO/IEC 8859-1:1998, 1998.

[Part2]

Fielding, R., Ed., Lafon, Y., Ed., and J. Reschke, Ed., “HTTP/1.1, part 2: Message Semantics”, Internet-Draft draft-ietf-httpbis-p2-semantics-19 (work in progress), March 2012.

[Part3]

Fielding, R., Ed., Lafon, Y., Ed., and J. Reschke, Ed., “HTTP/1.1, part 3: Message Payload and Content Negotiation”, Internet-Draft draft-ietf-httpbis-p3-payload-19 (work in progress), March 2012.

[Part6]

Fielding, R., Ed., Lafon, Y., Ed., Nottingham, M., Ed., and J. Reschke, Ed., “HTTP/1.1, part 6: Caching”, Internet-Draft draft-ietf-httpbis-p6-cache-19 (work in progress), March 2012.

[RFC1950]

Deutsch, L. and J-L. Gailly, “ZLIB Compressed Data Format Specification version 3.3”, RFC 1950, May 1996.

[RFC1951]

Deutsch, P., “DEFLATE Compressed Data Format Specification version 1.3”, RFC 1951, May 1996.

[RFC1952]

Deutsch, P., Gailly, J-L., Adler, M., Deutsch, L., and G. Randers-Pehrson, “GZIP file format specification version 4.3”, RFC 1952, May 1996.

[RFC2119]

Bradner, S., “Key words for use in RFCs to Indicate Requirement Levels”, BCP 14, RFC 2119, March 1997.

[RFC3986]

Berners-Lee, T., Fielding, R., and L. Masinter, “Uniform Resource Identifier (URI): Generic Syntax”, STD 66, RFC 3986, January 2005.

[RFC5234]

Crocker, D., Ed. and P. Overell, “Augmented BNF for Syntax Specifications: ABNF”, STD 68, RFC 5234, January 2008.

[USASCII]

American National Standards Institute, “Coded Character Set -- 7-bit American Standard Code for Information Interchange”, ANSI X3.4, 1986.

10.2. Informative References

[Kri2001]

Kristol, D., “HTTP Cookies: Standards, Privacy, and Politics”, ACM Transactions on Internet Technology Vol. 1, #2, November 2001, <http://arxiv.org/abs/cs.SE/0105018>.

[Nie1997]

Frystyk, H., Gettys, J., Prud'hommeaux, E., Lie, H., and C. Lilley, “Network Performance Effects of HTTP/1.1, CSS1, and PNG”, ACM Proceedings of the ACM SIGCOMM '97 conference on Applications, technologies, architectures, and protocols for computer communication SIGCOMM '97, September 1997, <http://doi.acm.org/10.1145/263105.263157>.

[Pad1995]

Padmanabhan, V. and J. Mogul, “Improving HTTP Latency”, Computer Networks and ISDN Systems v. 28, pp. 25-35, December 1995, <http://portal.acm.org/citation.cfm?id=219094>.

[RFC1919]

Chatel, M., “Classical versus Transparent IP Proxies”, RFC 1919, March 1996.

[RFC1945]

Berners-Lee, T., Fielding, R., and H. Nielsen, “Hypertext Transfer Protocol -- HTTP/1.0”, RFC 1945, May 1996.

[RFC2045]

Freed, N. and N. Borenstein, “Multipurpose Internet Mail Extensions (MIME) Part One: Format of Internet Message Bodies”, RFC 2045, November 1996.

[RFC2047]

Moore, K., “MIME (Multipurpose Internet Mail Extensions) Part Three: Message Header Extensions for Non-ASCII Text”, RFC 2047, November 1996.

[RFC2068]

Fielding, R., Gettys, J., Mogul, J., Nielsen, H., and T. Berners-Lee, “Hypertext Transfer Protocol -- HTTP/1.1”, RFC 2068, January 1997.

[RFC2145]

Mogul, J., Fielding, R., Gettys, J., and H. Nielsen, “Use and Interpretation of HTTP Version Numbers”, RFC 2145, May 1997.

[RFC2616]

Fielding, R., Gettys, J., Mogul, J., Frystyk, H., Masinter, L., Leach, P., and T. Berners-Lee, “Hypertext Transfer Protocol -- HTTP/1.1”, RFC 2616, June 1999.

[RFC2817]

Khare, R. and S. Lawrence, “Upgrading to TLS Within HTTP/1.1”, RFC 2817, May 2000.

[RFC2818]

Rescorla, E., “HTTP Over TLS”, RFC 2818, May 2000.

[RFC2965]

Kristol, D. and L. Montulli, “HTTP State Management Mechanism”, RFC 2965, October 2000.

[RFC3040]

Cooper, I., Melve, I., and G. Tomlinson, “Internet Web Replication and Caching Taxonomy”, RFC 3040, January 2001.

[RFC3864]

Klyne, G., Nottingham, M., and J. Mogul, “Registration Procedures for Message Header Fields”, BCP 90, RFC 3864, September 2004.

[RFC4033]

Arends, R., Austein, R., Larson, M., Massey, D., and S. Rose, “DNS Security Introduction and Requirements”, RFC 4033, March 2005.

[RFC4288]

Freed, N. and J. Klensin, “Media Type Specifications and Registration Procedures”, BCP 13, RFC 4288, December 2005.

[RFC4395]

Hansen, T., Hardie, T., and L. Masinter, “Guidelines and Registration Procedures for New URI Schemes”, BCP 115, RFC 4395, February 2006.

[RFC4559]

Jaganathan, K., Zhu, L., and J. Brezak, “SPNEGO-based Kerberos and NTLM HTTP Authentication in Microsoft Windows”, RFC 4559, June 2006.

[RFC5226]

Narten, T. and H. Alvestrand, “Guidelines for Writing an IANA Considerations Section in RFCs”, BCP 26, RFC 5226, May 2008.

[RFC5322]

Resnick, P., “Internet Message Format”, RFC 5322, October 2008.

[RFC6265]

Barth, A., “HTTP State Management Mechanism”, RFC 6265, April 2011.

[Spe]

Spero, S., “Analysis of HTTP Performance Problems”, <http://sunsite.unc.edu/mdma-release/http-prob.html>.

[Tou1998]

Touch, J., Heidemann, J., and K. Obraczka, “Analysis of HTTP Performance”, ISI Research Report ISI/RR-98-463, Aug 1998, <http://www.isi.edu/touch/pubs/http-perf96/>.
(original report dated Aug. 1996)

This section summarizes major differences between versions HTTP/1.0 and HTTP/1.1.¶

Clarify that the string "HTTP" in the HTTP-version ABFN production is case sensitive. Restrict the version numbers to be single digits due to the fact that implementations are known to handle multi-digit version numbers incorrectly. (Section 2.6)¶

Update use of abs_path production from RFC 1808 to the path-absolute + query components of RFC 3986. State that the asterisk form is allowed for the OPTIONS request method only. (Section 5.3)¶

Require that invalid whitespace around field-names be rejected. (Section 3.2)¶

Rules about implicit linear whitespace between certain grammar productions have been removed; now whitespace is only allowed where specifically defined in the ABNF. (Section 3.2.1)¶

The NUL octet is no longer allowed in comment and quoted-string text. The quoted-pair rule no longer allows escaping control characters other than HTAB. Non-ASCII content in header fields and reason phrase has been obsoleted and made opaque (the TEXT rule was removed). (Section 3.2.4)¶

Empty list elements in list productions have been deprecated. (Section 3.2.5)¶

Require recipients to handle bogus Content-Length header fields as errors. (Section 3.3)¶

Remove reference to non-existent identity transfer-coding value tokens. (Sections 3.3 and 4)¶

Clarification that the chunk length does not include the count of the octets in the chunk header and trailer. Furthermore disallowed line folding in chunk extensions, and deprecate their use. (Section 4.1)¶

Registration of Transfer Codings now requires IETF Review (Section 7.4)¶

Remove hard limit of two connections per server. Remove requirement to retry a sequence of requests as long it was idempotent. Remove requirements about when servers are allowed to close connections prematurely. (Section 6.3.3)¶

Remove requirement to retry requests under certain cirumstances when the server prematurely closes the connection. (Section 6.4)¶

Change ABNF productions for header fields to only define the field value.¶

Clarify exactly when close connection options must be sent. (Section 6.1)¶

Define the semantics of the "Upgrade" header field in responses other than 101 (this was incorporated from [RFC2817]). (Section 6.5)¶

Registration of Upgrade tokens now requires IETF Review (Section 7.6)¶

Extracted relevant partitions from [RFC2616].¶

Closed issues: ¶

• <http://tools.ietf.org/wg/httpbis/trac/ticket/1>: "HTTP Version should be case sensitive" (<http://purl.org/NET/http-errata#verscase>)
• <http://tools.ietf.org/wg/httpbis/trac/ticket/2>: "'unsafe' characters" (<http://purl.org/NET/http-errata#unsafe-uri>)
• <http://tools.ietf.org/wg/httpbis/trac/ticket/3>: "Chunk Size Definition" (<http://purl.org/NET/http-errata#chunk-size>)
• <http://tools.ietf.org/wg/httpbis/trac/ticket/4>: "Message Length" (<http://purl.org/NET/http-errata#msg-len-chars>)
• <http://tools.ietf.org/wg/httpbis/trac/ticket/8>: "Media Type Registrations" (<http://purl.org/NET/http-errata#media-reg>)
• <http://tools.ietf.org/wg/httpbis/trac/ticket/11>: "URI includes query" (<http://purl.org/NET/http-errata#uriquery>)
• <http://tools.ietf.org/wg/httpbis/trac/ticket/15>: "No close on 1xx responses" (<http://purl.org/NET/http-errata#noclose1xx>)
• <http://tools.ietf.org/wg/httpbis/trac/ticket/16>: "Remove 'identity' token references" (<http://purl.org/NET/http-errata#identity>)
• <http://tools.ietf.org/wg/httpbis/trac/ticket/26>: "Import query BNF"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/31>: "qdtext BNF"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/35>: "Normative and Informative references"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/42>: "RFC2606 Compliance"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/45>: "RFC977 reference"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/46>: "RFC1700 references"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/47>: "inconsistency in date format explanation"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/48>: "Date reference typo"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/65>: "Informative references"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/66>: "ISO-8859-1 Reference"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/86>: "Normative up-to-date references"

Other changes: ¶

• Update media type registrations to use RFC4288 template.
• Use names of RFC4234 core rules DQUOTE and HTAB, fix broken ABNF for chunk-data (work in progress on <http://tools.ietf.org/wg/httpbis/trac/ticket/36>)

Closed issues: ¶

• <http://tools.ietf.org/wg/httpbis/trac/ticket/19>: "Bodies on GET (and other) requests"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/55>: "Updating to RFC4288"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/57>: "Status Code and Reason Phrase"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/82>: "rel_path not used"

Ongoing work on ABNF conversion (<http://tools.ietf.org/wg/httpbis/trac/ticket/36>): ¶

• Get rid of duplicate BNF rule names ("host" -> "uri-host", "trailer" -> "trailer-part").
• Avoid underscore character in rule names ("http_URL" -> "http-URL", "abs_path" -> "path-absolute").
• Add rules for terms imported from URI spec ("absoluteURI", "authority", "path-absolute", "port", "query", "relativeURI", "host) — these will have to be updated when switching over to RFC3986.
• Synchronize core rules with RFC5234.
• Get rid of prose rules that span multiple lines.
• Get rid of unused rules LOALPHA and UPALPHA.
• Move "Product Tokens" section (back) into Part 1, as "token" is used in the definition of the Upgrade header field.
• Add explicit references to BNF syntax and rules imported from other parts of the specification.
• Rewrite prose rule "token" in terms of "tchar", rewrite prose rule "TEXT".

Closed issues: ¶

• <http://tools.ietf.org/wg/httpbis/trac/ticket/51>: "HTTP-date vs. rfc1123-date"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/64>: "WS in quoted-pair"

Ongoing work on IANA Message Header Field Registration (<http://tools.ietf.org/wg/httpbis/trac/ticket/40>): ¶

• Reference RFC 3984, and update header field registrations for headers defined in this document.

Ongoing work on ABNF conversion (<http://tools.ietf.org/wg/httpbis/trac/ticket/36>): ¶

• Replace string literals when the string really is case-sensitive (HTTP-version).

Closed issues: ¶

• <http://tools.ietf.org/wg/httpbis/trac/ticket/28>: "Connection closing"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/97>: "Move registrations and registry information to IANA Considerations"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/120>: "need new URL for PAD1995 reference"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/127>: "IANA Considerations: update HTTP URI scheme registration"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/128>: "Cite HTTPS URI scheme definition"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/129>: "List-type headers vs Set-Cookie"

Ongoing work on ABNF conversion (<http://tools.ietf.org/wg/httpbis/trac/ticket/36>): ¶

• Replace string literals when the string really is case-sensitive (HTTP-Date).
• Replace HEX by HEXDIG for future consistence with RFC 5234's core rules.

Closed issues: ¶

• <http://tools.ietf.org/wg/httpbis/trac/ticket/34>: "Out-of-date reference for URIs"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/132>: "RFC 2822 is updated by RFC 5322"

Ongoing work on ABNF conversion (<http://tools.ietf.org/wg/httpbis/trac/ticket/36>): ¶

• Use "/" instead of "|" for alternatives.
• Get rid of RFC822 dependency; use RFC5234 plus extensions instead.
• Only reference RFC 5234's core rules.
• Introduce new ABNF rules for "bad" whitespace ("BWS"), optional whitespace ("OWS") and required whitespace ("RWS").
• Rewrite ABNFs to spell out whitespace rules, factor out header field value format definitions.

Closed issues: ¶

• <http://tools.ietf.org/wg/httpbis/trac/ticket/30>: "Header LWS"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/52>: "Sort 1.3 Terminology"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/63>: "RFC2047 encoded words"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/74>: "Character Encodings in TEXT"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/77>: "Line Folding"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/83>: "OPTIONS * and proxies"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/94>: "reason-phrase BNF"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/111>: "Use of TEXT"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/118>: "Join "Differences Between HTTP Entities and RFC 2045 Entities"?"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/134>: "RFC822 reference left in discussion of date formats"

Final work on ABNF conversion (<http://tools.ietf.org/wg/httpbis/trac/ticket/36>): ¶

• Rewrite definition of list rules, deprecate empty list elements.
• Add appendix containing collected and expanded ABNF.

Other changes: ¶

• Rewrite introduction; add mostly new Architecture Section.
• Move definition of quality values from Part 3 into Part 1; make TE request header field grammar independent of accept-params (defined in Part 3).

Closed issues: ¶

• <http://tools.ietf.org/wg/httpbis/trac/ticket/161>: "base for numeric protocol elements"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/162>: "comment ABNF"

Partly resolved issues: ¶

• <http://tools.ietf.org/wg/httpbis/trac/ticket/88>: "205 Bodies" (took out language that implied that there might be methods for which a request body MUST NOT be included)
• <http://tools.ietf.org/wg/httpbis/trac/ticket/163>: "editorial improvements around HTTP-date"

Closed issues: ¶

• <http://tools.ietf.org/wg/httpbis/trac/ticket/93>: "Repeating single-value headers"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/131>: "increase connection limit"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/157>: "IP addresses in URLs"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/172>: "take over HTTP Upgrade Token Registry"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/173>: "CR and LF in chunk extension values"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/184>: "HTTP/0.9 support"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/188>: "pick IANA policy (RFC5226) for Transfer Coding / Content Coding"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/189>: "move definitions of gzip/deflate/compress to part 1"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/194>: "disallow control characters in quoted-pair"

Partly resolved issues: ¶

• <http://tools.ietf.org/wg/httpbis/trac/ticket/148>: "update IANA requirements wrt Transfer-Coding values" (add the IANA Considerations subsection)

Closed issues: ¶

• <http://tools.ietf.org/wg/httpbis/trac/ticket/201>: "header parsing, treatment of leading and trailing OWS"

Partly resolved issues: ¶

• <http://tools.ietf.org/wg/httpbis/trac/ticket/60>: "Placement of 13.5.1 and 13.5.2"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/200>: "use of term "word" when talking about header structure"

Closed issues: ¶

• <http://tools.ietf.org/wg/httpbis/trac/ticket/73>: "Clarification of the term 'deflate'"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/83>: "OPTIONS * and proxies"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/122>: "MIME-Version not listed in P1, general header fields"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/143>: "IANA registry for content/transfer encodings"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/165>: "Case-sensitivity of HTTP-date"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/200>: "use of term "word" when talking about header structure"

Partly resolved issues: ¶

• <http://tools.ietf.org/wg/httpbis/trac/ticket/196>: "Term for the requested resource's URI"

Closed issues: ¶

• <http://tools.ietf.org/wg/httpbis/trac/ticket/28>: "Connection Closing"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/90>: "Delimiting messages with multipart/byteranges"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/95>: "Handling multiple Content-Length headers"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/109>: "Clarify entity / representation / variant terminology"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/220>: "consider removing the 'changes from 2068' sections"

Partly resolved issues: ¶

• <http://tools.ietf.org/wg/httpbis/trac/ticket/159>: "HTTP(s) URI scheme definitions"

Closed issues: ¶

• <http://tools.ietf.org/wg/httpbis/trac/ticket/193>: "Trailer requirements"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/204>: "Text about clock requirement for caches belongs in p6"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/221>: "effective request URI: handling of missing host in HTTP/1.0"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/248>: "confusing Date requirements for clients"

Partly resolved issues: ¶

• <http://tools.ietf.org/wg/httpbis/trac/ticket/95>: "Handling multiple Content-Length headers"

Closed issues: ¶

• <http://tools.ietf.org/wg/httpbis/trac/ticket/75>: "RFC2145 Normative"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/159>: "HTTP(s) URI scheme definitions" (tune the requirements on userinfo)
• <http://tools.ietf.org/wg/httpbis/trac/ticket/210>: "define 'transparent' proxy"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/224>: "Header Classification"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/233>: "Is * usable as a request-uri for new methods?"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/240>: "Migrate Upgrade details from RFC2817"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/276>: "untangle ABNFs for header fields"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/279>: "update RFC 2109 reference"

Closed issues: ¶

• <http://tools.ietf.org/wg/httpbis/trac/ticket/53>: "Allow is not in 13.5.2"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/95>: "Handling multiple Content-Length headers"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/276>: "untangle ABNFs for header fields"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/286>: "Content-Length ABNF broken"

Closed issues: ¶

• <http://tools.ietf.org/wg/httpbis/trac/ticket/273>: "HTTP-version should be redefined as fixed length pair of DIGIT . DIGIT"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/282>: "Recommend minimum sizes for protocol elements"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/283>: "Set expectations around buffering"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/288>: "Considering messages in isolation"

Closed issues: ¶

• <http://tools.ietf.org/wg/httpbis/trac/ticket/100>: "DNS Spoofing / DNS Binding advice"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/254>: "move RFCs 2145, 2616, 2817 to Historic status"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/270>: "\-escaping in quoted strings"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/305>: "'Close' should be reserved in the HTTP header field registry"

Closed issues: ¶

• <http://tools.ietf.org/wg/httpbis/trac/ticket/186>: "Document HTTP's error-handling philosophy"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/215>: "Explain header registration"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/219>: "Revise Acknowledgements Sections"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/297>: "Retrying Requests"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/318>: "Closing the connection on server error"

Closed issues: ¶

• <http://tools.ietf.org/wg/httpbis/trac/ticket/166>: "Clarify 'User Agent'"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/300>: "Define non-final responses"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/323>: "intended maturity level vs normative references"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/324>: "Intermediary rewriting of queries"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/158>: "Proxy-Connection and Keep-Alive"

Closed issues: ¶

• <http://tools.ietf.org/wg/httpbis/trac/ticket/250>: "message-body in CONNECT response"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/302>: "Misplaced text on connection handling in p2"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/335>: "wording of line folding rule"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/343>: "chunk-extensions"
• <http://tools.ietf.org/wg/httpbis/trac/ticket/346>: "make IANA policy definitions consistent"