Протокол HTTP 1.1

Протокол HTTP 1.1

Маркеры продуктов должны быть короткими и по сути - использование их

для рекламы или другой несущественной информации однозначно запрещено. Хотя

в лексеме product-version может встречаться любой символ, все же ее следует

использовать только для идентификатора версии (то есть, последовательным

версиям одной и той же программы надлежит иметь отличия только в части

product-version лексемы product.

3.9 Величины качества (Quality Values).

HTTP использует короткие числа "с плавающей точкой" для указания

относительной важности ("веса") различных оговоренных параметров. Вес - это

нормализованое вещественное число в диапазоне от 0 до 1, где 0 -

минимальное, а 1 - максимальное значение. HTTP/1.1 приложения не должны

генерировать более трех цифр после десятичной точки. Пользовательским

конфигурациям этих значений следует также ограничиваться этим режимом.

qvalue = ( "0" [ "." 0*3DIGIT ] ) | ( "1" [ "." 0*3("0") ] )

"Величины качества" - не корректное название, так как эти значения

просто представляют отношение снижения производительности к желательному

качеству.

3.10 Метки языков (Language Tags).

Метка языка идентифицирует естественный язык: разговорный, письменный,

или другой используемый людьми для обмена информацмей с другими людьми.

Машинные языки являются исключением. HTTP использует метки языков внутри

полей Accept-Language и Content-Language.

Синтаксис и запись меток языка в HTTP те же, что определены в RFC

1766. То есть, метка языка состоит из одной или нескольких частей: метка

первичного языка и, возможно пустой, ряд подчиненных меток:

language-tag = primary-tag *( "-" subtag )

primary-tag = 1*8ALPHA subtag = 1*8ALPHA

Внутри метки не допустимы пробелы и все метки не чувствительны к

регистру. Пространство имен меток языка управляется IANA. Например метки

содержат:

en, en-US, en-cockney, i-cherokee, x-pig-latin

Любая двухсимвольная первичная метка является меткой аббревеатуры

языка ISO 639, а любая двухсимвольная подчиненная метка является меткой

кода страны ISO 3166. (Последние три метки из вышеперечисленных - не

зарегистрированные метки; все, кроме последней - примеры меток, которые

скорее всего ьудут зарегистрированы в будущем.)

3.11 Метки объектов (Entity Tags).

Метки объектов используются для сравнения двух или более объектов

одного и того же запрошенного ресурса. HTTP/1.1 использует метки объектов в

полях заголовка ETag, If-Match, If-None-Match, и If-Range. Метка объекта

состоит из непрозрачной строки, заключенной в кавычки (opaque quoted

string), возможно предваренной индикатором слабости (weakness indicator).

entity-tag = [ weak ] opaque-tag

weak = "W/" opaque-tag = quoted-string

"Сильная метка объекта" ("strong entity tag") может быть

распространнена на два объекта ресурса, только тогда, когда они пооктетно

эквивалентны.

"Слабая метка объекта" ("weak entity tag"), обозначяемая префиксом

"W/", может быть распространена на два объекта ресурса только тогда, когда

объекты эквивалентны и могли бы заменять друг друга без значительного

изменения в семантике. Слабая метка объекта может использоваться только для

слабого сравнения (weak comparison).

Метка объекта должна быть уникальна среди всех версий всех объектов,

связанных с конкретным ресурсом. Данное значение метки объекта может

использоваться для объектов, полученных запросами различных URI без

предположения эквивалентности этих объектов.

3.12 Единицы измерения диапазонов (Range Units).

HTTP/1.1 позволяет клиенту запрашивать только часть объекта. HTTP/1.1

использует еденицы измерения диапазонов в полях заголовка Range и Content-

Range. Объект может быть разбит на части соответственно различным

структурным модулям.

range-unit = bytes-unit | other-range-unit

bytes-unit = "bytes" other-range-unit = token

Единственая еденица измерения диапазонов, определенная в HTTP/1.1 -

это "bytes". Реализации HTTP/1.1 могут игнорировать диапазоны, определенные

с использованием других едениц измерения. HTTP/1.1 был разработан, чтобы

обеспечения возможности реализации приложений, которые не зависят от знания

диапазонов.

4. HTTP сообщение (HTTP Message).

4.1 Типы сообщений.

HTTP сообщения делятся на запросы клиента серверу и ответы сервера

клиенту.

HTTP-message = Request | Response ; сообщения HTTP/1.1

Сообщения запроса и ответа используют обобщенный формат сообщения RFC

822 для пересылки объектов (полезной нагрузки сообщения). Оба типа

сообщений выглядят следующим образом: сначала идет начальная строка (start-

line), затем один или несколько полей заголовка (называемых также просто

"заголовки"), затем пустая строка (то есть строка, равная CRLF),

указывающая конец полей заголовка, а затем, возможно, тело сообщения.

generic-message = start-line *message-header CRLF [ message-body ]

start-line = Request-Line | Status-Line

В интересах ошибкоустойчивости, серверам следует игнорировать все

пустые строки, полученные перед строкой запроса (Request-Line). Другими

словами, если сервер читает поток протокола и в самом начале сообщения

получает CRLF, то ему следует этот CRLF игнорировать.

Некоторые ошибочные реализации HTTP/1.0 клиентов генерируют

дополнительные CRLF после запроса POST. Стоит вновь повторить, что это явно

запрещено нормальной записью Бекуса-Наура. HTTP/1.1 клиент не должен

добавлять дополнительные CRLF перед запросом и после него.

4.2 Заголовки сообщений.

Поля заголовков HTTP, которые включают поля общих заголовков (general-

header), заголовков запроса (request-header), заголовков ответа (response-

header), и заголовков объекта (entity-header), имеют такой же обобщенный

формат, как тот, что описан в разделе 3.1 RFC 822. Каждое поле заголовка

состоит из имени поля, двоеточия (":") и значения поля. Имена полей не

чувствительны к регистру. Значению поля может предшествовать любое число

LWS, хотя предпочтителен одиночный SP. Поля заголовка могут занимать

несколько строк. При этом каждая следующая строка продолжения начинается по

крайней мере одним SP или HT. Приложениям следует придерживаться "общей

формы" ("common form") при генерации HTTP конструкций, так как могут

существовать реализации, которые не в состоянии принимать что-либо кроме

общих форм.

message-header = field-name ":" [ field-value ] CRLF

field-name = token field-value = *( field-content | LWS )

field-content =

Порядок, в котором получены поля заголовка с различными именами не

имеет значения. Однако "хорошей практикой" является то, что сначала

посылаются поля общих заголовков, затем поля заголовков запроса или

заголовков ответа, и, наконец, поля заголовков объекта.

Несколько полей заголовка с одиннаковыми именами могут присутствовать

в сообщении тогда и только тогда, когда все значения полей, входящих в

заголовок, определяют разделенный запятыми список [то есть #(value)].

Должно быть возможно объединить несколько таких полей заголовка в одну пару

"имя поля: значение поля" (не измененяя этим семантику сообщения) путем

присоединения каждого последующего значения поля к первому через запятые.

Порядок, в котором получены поля с одинаковыми именами, имеет значение для

интерпретации объединенного значения поля, и, следовательно, прокси-сервер

не должен изменять порядок значений этого поля при пересылке.

4.3 Тело cообщения.

Тело HTTP сообщения (message-body), если оно присутствует,

используется для передачи тела объекта, связанного с запросом или ответом.

Тело сообщения (message-body) отличается от тела объекта (entity-body)

только в том случае, когда применяется кодирование передачи, что

указывается полем заголовка Transfer-Encodingы.

message-body = entity-body |

Поле Transfer-Encoding должно использоваться для указания любого

кодирования передачи, примененного приложением в целях гарантирования

безопасной и правильной передачи сообщения. Поле Transfer-Encoding - это

свойство сообщения, а не объекта, и, таким образом, может быть добавлено

или удалено любым приложением в цепочке запросов/ответов.

Правила, устанавливающие допустимость тела сообщения в сообщении,

различаются для запросов и ответов.

Присутствие тела сообщения в запросе отмечается добавлением к

заголовкам запроса поля заголовка Content-Length или Transfer-Encoding. ело

сообщения (message-body) может быть добавлено в запрос только тогда, когда

метод запроса допускает тело объекта (entity-body).

Включать или не включать тело сообщения (message-body) в сообщение

ответа зависит как от метода запроса, так и от кода состояния ответа. Все

ответы на запрос с методом HEAD не должны включать тело сообщения (message-

body), даже если присутствуют поля заголовка объекта (entity-header),

заставляющие поверить в присутствие объекта. Никакие ответы с

информационными кодами состояния 1xx, кодом 204 (Нет содержимого, No

Content) и кодом 304 (Не модифицирован, Not Modified) не должны содержать

тела сообщения (message-body). Все остальные ответы содержат тело

сообщения, даже если оно имеет нулевую длину.

4.4 Длина сообщения.

Когда тело сообщения (message-body) присутствует в сообщении, длина

этого тела определяется одним из следующих методов (в порядке старшинства):

1. Любое сообщение ответа, которое не должно включать тело сообщения

(message-body) (например ответы с кодами состояния 1xx, 204, 304 и

все ответы на запрос HEAD) всегда завершается пустой строкой после

полей заголовка, независимо от полей заголовка объекта (entity-

header fields), представленных в сообщении.

2. Если поле заголовка Transfer-Encoding присутствует и указывает на

применение кодирования передачи "chunked", то длина определяется

кодированием по кускам (chunked encoding).

3. Если поле заголовка Content-Length присутствует, то его значение

представляет длину тела сообщения (message-body) в байтах.

4. Если сообщение использует медиатип "multipart/byteranges", который

саморазграничен, то он и определяет длину. Этот медиа тип не должен

использоваться, если отправитель не знает, способен ли получатель

его обработать; присутствие в запросе заголовка Range с несколькими

спецификаторами диапазонов байтов (byte-range) подразумевает, что

клиент может анализировать multipart/byteranges ответы.

5. Длина определяется закрытием соединения сервером. (Закрытие

соединения не может использоваться для указания конца тела запроса,

так как в этом случае у сервера не остается никакой возможности

послать обратно ответ).

Для совместимости с HTTP/1.0 приложениями HTTP/1.1 запросы, содержащие

тело сообщения (message-body) должны включать допустимое поле заголовка

Content-Length, пока не известно, что сервер является HTTP/1.1 совместимым.

Если запрос содержит тело сообщения (message-body), и Content-Length не

указано, серверу следует послать ответ с кодом состояния 400 (Испорченный

Запрос, Bad Request), если он не может определить длину сообщения, или с

кодом состояния 411 (Требуется длина, Length Required), если он настаивает

на получении Content-Length.

Все HTTP/1.1 приложения, которые получают объекты, должны понимать

кодирование передачи типа "chunked", таким образом разрешается

использование данного механизма для таких сообщений, длина которых не может

быть определена заранее.

Сообщения не должны одновременно включать и поле заголовка Content-

Length и применять кодирование передачи типа "chunked". Если поступило

сообщение с полем Content-Length и закодированное с применением кодирования

передачи "chunked", то поле Content-Length должно игнорироваться.

Если поле Content-Length присутствует в сообщении, которое допускает

наличие тела сообщения (message-body), то значение поля должно точно

соответствовать числу октетов в теле сообщения. HTTP/1.1 агенты

пользователя должны информировать пользователя в случае получения и

обнаружения недопустимой длины.

4.5 Общие поля заголовка.

Имеется несколько полей заголовка, которые применяются как для

сообщений запросов, так и для сообщений ответов, но которые не применяются

к передаваемому объекту. Эти поля заголовка применяются только к

передаваемому сообщению.

general-header = Cache-Control | Connection | Date | Pragma | Transfer-

Encoding | Upgrade | Via

Имена общих полей заголовка (general-header fields) могут быть надежно

расширены только в сочетании с изменением версии протокола. Однако, новые

или экспериментальные поля заголовка могут получить семантику общих полей

заголовка (general-header fields), если все стороны соединения распознают

их как общие поля заголовка. Нераспознанные поля заголовка обрабатываются

как поля заголовка объекта (entity-header).

5. Запрос (Request).

Сообщение запроса сервера клиентом содержит в первой строке: метод,

который нужно применить к ресурсу, идентификатор ресурса и используемую

версию протокола.

Request = Request-Line *( general-header | request-header | entity-

header ) CRLF [ message-body ]

5.1 Строка запроса (Request-Line).

Строка запроса (Request-Line) начинается с лексемы метода, затем

следует запрашиваемый URI (Request-URI), версия протокола и CRLF. Эти

элементы разделяются SP. В строке запроса (Request-Line) не допустимы CR и

LF, исключение составляет конечная последовательность CRLF.

Request-Line = Method SP Request-URI SP HTTP-Version CRLF

5.1.1 Метод (Method).

Лексема метода указывает метод, который нужно применить к ресурсу,

идентифицированному запрашиваемым URI (Request-URI). Метод чувствителен к

регистру.

Method = "OPTIONS" | "GET" | "HEAD" | "POST" | "PUT" | "DELETE" |

"TRACE" | extension-method

extension-method = token

Список методов, применимых к ресурсу, может быть указан в поле

заголовка Allow. Возврашаемый код состояния ответа всегда сообщает клиенту,

допустим ли метод для ресурса в настоящее время, так как набор допустимых

методов может изменяться динамически. Серверам следует возвратить код

состояния 405 (Метод не допустим, Method Not Allowed), если метод известен

серверу, но не применим для запрошенного ресурса, и 501 (Не реализовано,

Not Implemented), если метод не распознан или не реализован сервером.

Список методов, известных серверу, может быть указан в поле заголовка

ответа Public.

Методы GET и HEAD должны поддерживаться всеми универсальными (general-

purpose) серверами. Остальные методы опциональны.

5.1.2 URI запроса (Request-URI).

URI запроса (Request-URI) - это Единообразный Идентификатор Ресурса

(URL), который идентифицирует ресурс запроса.

Request-URI = "*" | absoluteURI | abs_path

Три опции для URI запроса (Request-URI) зависят от характера запроса.

Звездочка "*" означает, что запрашивается не специфический ресурс, а сервер

непосредственно, и допустим только в том случае, когда используемый метод

не обязательно обращается к ресурсу. В качестве примера:

OPTIONS * HTTP/1.1

absoluteURI необходим, когда запрос производится через прокси-сервер.

Прокси-сервер перенаправляет запрос на сервер или обслуживает его,

пользуясь кэшем, и возвращает ответ. Прокси-сервер может переслать запрос

другому прокси-серверу или непосредственно серверу, определенному

absoluteURI. Чтобы избежать зацикливания запроса прокси-сервер должен быть

способен распознавать все имена сервера, включая любые псевдонимы,

локальные разновидности, и числовые IP адреса. Request-Line может быть,

например, таким:

GET http://www.w3.org/pub/WWW/TheProject.html HTTP/1.1

Чтобы обеспечить переход к absoluteURI во всех запросах в будущих

версиях HTTP, все HTTP/1.1 сервера должны принимать absoluteURI в запросах,

хотя HTTP/1.1 клиенты будут генерировать их только в запросах к прокси-

серверам.

Наиболее общая форма Request-URI используется для идентификации

ресурса на первоначальном сервере или шлюзе. В этом случае абсолютный путь

URI должен быть передан как Request-URI, а сетевое расположение URI

(net_loc) должно быть передано в поле заголовка Host. Для последнего

примера клиент, желающий получить ресурс непосредственно с первоначального

сервера должен создать TCP соединение на 80 порт хоста "www.w3.org" и

послать строки:

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

и далее остаток запроса. Абсолютный путь не может быть пустым; если

оригинальный URI пуст, то он должен запрашиваться как "/" (корневой каталог

сервера).

Если прокси-сервер получает запрос без пути в Request-URI, и метод

запроса допускает форму запроса "*", то последний прокси-сервер в цепочке

запросов должен передать запрос, в котором Request-URI равен "*". Например

запрос

OPTIONS http://www.ics.uci.edu:8001 HTTP/1.1

был бы передан прокси-сервером в виде

OPTIONS * HTTP/1.1 Host: www.ics.uci.edu:8001

после соединения с портом 8001 хоста "www.ics.uci.edu".

Первоначальный сервер должен декодировать Request-URI, чтобы правильно

интерпретировать запрос. Серверам сдледует отвечать на недопустимые Request-

URI соответствующим кодом состояния.

В запросах, пересылаемых прокси-сервером, часть "abs_path" URI запроса

(Request-URI) никогда не должна перезаписываться, за исключением случая,

отмеченного выше, когда пустой abs_path заменяется на "*", независимо от

внутренней реализации прокси-сервера.

Правило "ничто не перезаписывать" предохраняет прокси-сервера от

изменения значения запроса, в котором первоначальный сервер неправильно

использует не зарезервированные символы URL для своих целей.

5.2 Ресурс, идентифицируемый запросом.

Первоначальные HTTP/1.1 сервера должны учитывать, что точный ресурс,

идентифицируемый интернет-запросом определяется путем исследования

запрашиваемого URI (Request-URI) и поля заголовка Host.

Первоначальный сервер, который не различает ресурсы по запрошенному

хосту (host), может игнорировать значение поля заголовка Host.

Первоначальный сервер, который различает ресурсы на основании

запрошенного хоста (host) (иногда называемые виртуальными хостами или

vanity hostnames) должен пользоваться следующими правилами для определения

ресурса, запрошенного в HTTP/1.1 запросе:

1. Если Request-URI - это absoluteURI, то хост - это часть Request-

URI. Любые значения поля заголовка Host в запросе должны

игнорироваться.

2. Если Request-URI - не absoluteURI, а запрос содержит поле заголовка

Host, то хост определяется значением поля заголовка Host.

3. Если хоста, определенного правилами 1 или 2 не существует на

сервере, кодом состояния ответа должен быть 400 (Испорченный Запрос,

Bad Request).

Получатели HTTP/1.0 запроса, в котором отсутствует поле заголовка

Host, могут попытаться использовать эвристику (например, исследовать путь в

URI на предмет уникальности на каком-либо из хостов) для определения какой

именно ресурс запрашивается.

5.3 Поля заголовка запроса.

Поля заголовка запроса позволяют клиенту передать серверу

дополнительную информацию о запросе и о самом клиенте. Эти поля действуют

как модификаторы запроса с семантикой, эквивалентной параметрам вызова

методов в языках программирования.

request-header = Accept | Accept-Charset | Accept-Encoding | Accept-

Language | Authorization | From | Host | If-Modified-Since | If-Match

| If-None-Match | If-Range | If-Unmodified-Since | Max-Forwards |

Proxy-Authorization | Range | Referer | User-Agent

Множество имен полей заголовка запроса (Request-header) может быть

надежно расширено только в сочетании с изменением версии протокола. Однако,

новые или экспериментальные поля заголовка могут получить семантику полей

заголовка запроса (Request-header), если все стороны соединения распознают

их как поля заголовка запроса (Request-header). Нераспознанные поля

заголовка обрабатываются как поля заголовка объекта (entity-header).

6 Ответ (Response).

После получения и интерпретации сообщения запроса, сервер отвечает

сообщением HTTP ответа.

Response = Status-Line *( general-header | response-header | entity-

header ) CRLF [ message-body ]

6.1 Строка состояния (Status-Line).

Первая строка ответа - это строка состояния (Status-Line). Она состоит

из версии протокола (HTTP-Version), числового кода состояния (Status-Code)

и поясняющей фразы (Reason-Phrase) разделенных символами SP. CR и LF не

допустимы в Status-Line, за исключением конечной последовательности CRLF.

Status-Line = HTTP-Version SP Status-Code SP Reason-Phrase CRLF

6.1.1 Код состояния и поясняющая фраза.

Элемент код состояния (Status-Code) - это целочисленный трехразрядный

код результата попытки понять и выполнить запрос. Эти коды полностью

определены в разделе 10. Поясняющая фраза (Reason-Phrase) предназначена для

короткого текстового описания кода состояния. Код состояния (Status-Code)

предназначен для использования автоматами, а поясняющая фраза предназначена

для живых пользователей. От клиента не требуется исследовать или отображать

поясняющую фразу (Reason-Phrase).

Первая цифра кода состояния определяет класс ответа. Последние две

цифры не имеют определенной роли в классификации. Имеется 5 значений первой

цифры:

- 1xx: Информационные коды - запрос получен, продолжается обработка.

- 2xx: Успешные коды - действие было успешно получено, понято и

обработано.

- 3xx: Коды перенаправления - для выполнения запроса должны быть

предприняты дальнейшие действия.

- 4xx: Коды ошибок клиента - запрос имеет плохой синтаксис или не может

быть выполнен.

- 5xx: Коды ошибок сервера - сервер не в состоянии выполнить правильный

запрос.

Конкретные значения числовых кодов состояния, определенных в HTTP/1.1, и

примерный набор соответствующих поясняющих фраз (Reason-Phrase) приводятся

ниже. Поясняющие фразы (Reason-Phrase), перечисленные здесь являются

рекомендуемыми, но могут быть заменены на эквивалентные не влияя на

протокол.

Status-Code = "100" ; Продолжать, Continue |

"101" ; Переключение протоколов, ; Switching Protocols |

"200" ; OK |

"201" ; Создан, Created |

"202" ; Принято, Accepted |

"203" ; Не авторская информация, ; Non-Authoritative

Information |

"204" ; Нет содержимого, No Content |

"205" ; Сбросить содержимое, Reset ; Content |

"206" ; Частичное содержимое, Partial ; Content |

"300" ; Множественный выбор, Multiple ; Choices |

"301" ; Постоянно перемещен, Moved ; Permanently |

"302" ; Временно перемещен, Moved ; Temporarily |

"303" ; Смотреть другой, See Other |

"304" ; Не модифицирован, Not Modified |

"305" ; Используйте прокси-сервер, Use ; Proxy |

"400" ; Испорченный запрос, Bad Request |

"401" ; Несанкционированно, Unauthorized |

"402" ; Требуется оплата, Payment ; Required |

"403" ; Запрещено, Forbidden |

"404" ; Не найден, Not Found |

"405" ; Метод не допустим, Method Not ; Allowed |

"406" ; Не приемлем, Not Acceptable |

"407" ; Требуется установление ; подлинности через прокси-

сервер, ; Proxy Authentication Required |

"408" ; Истекло время ожидания запроса, ; Request Timeout |

"409" ; Конфликт, Conflict |

"410" ; Удален, Gone |

"411" ; Требуется длина, Length Required |

"412" ; Предусловие неверно, ; Precondition Failed |

"413" ; Объект запроса слишком большой, ; Request Entity

Too Large |

"414" ; URI запроса слишком длинный, ; Request-URI Too Long

|

"415" ; Неподдерживаемый медиатип, ; Unsupported Media Type

|

"500" ; Внутренняя ошибка сервера, ; Internal Server Error

|

"501" ; Не реализовано, Not Implemented |

"502" ; Ошибка шлюза, Bad Gateway |

"503" ; Сервис недоступен, Service ; Unavailable |

"504" ; Истекло время ожидания от шлюза, ; Gateway Timeout

|

"505" ; Не поддерживаемая версия HTTP, ; HTTP Version Not

Supported | extension-code

extension-code = 3DIGIT

Reason-Phrase = *

Коды состояния HTTP расширяемы. HTTP приложениям не требуется понимать

значение всех зарегистрированных кодов состояния, хотя их понимание очень

желательно. Приложения должны понимать класс любого кода состояния, который

обозначается первой цифрой, и обрабатывать любой нераспознанный ответ как

эквивалентный коду состояния x00 этого класса, за исключением тех случаев,

когда нераспознанный ответ не должен кэшироваться. Например, если клиентом

получен и не был распознан код состояния 431, то он может безопасно

считать, что в запросе что-то было неправильно и обрабатывать ответ, как

если бы был получен код состояния 400. В таких случаях агентам пользователя

следует представить пользователю объект, возвращенный в ответе, так как

этот объект, вероятно, включает читабельную для человека информацию,

которая поясняет необычное состояние.

6.2 Поля заголовка ответа.

Поля заголовка ответа (response-header fields) позволяют серверу

передавать дополнительную информацию об ответе, которая не может быть

помещена в строку состояния Status-Line. Эти поля заголовка дают информацию

о сервере и о дальнейшем доступе к ресурсу, указанному этим Request-URI.

response-header = Age | Location | Proxy-Authenticate | Public | Retry-

After | Server | Vary | Warning | WWW-Authenticate

Множество имен полей заголовка ответа (Response-header) может быть

надежно расширенО только в сочетании с изменением версии протокола. Однако,

новые или экспериментальные поля заголовка могут получить семантику полей

заголовка ответа (Response-header), если все стороны соединения распознают

их как поля заголовка ответа (Response-header). Нераспознанные поля

заголовка обрабатываются как поля заголовка объекта (entity-header).

7 Объект (Entity).

Сообщения запросов и ответов могут передать объект, если это не

запрещено методом запроса или кодом состояния ответа. Объект состоит из

полей заголовка объекта (entity-header) и тела объекта (entity-body), хотя

некоторые ответы могут включать только заголовки объекта (entity-headers).

Этот раздел относится как к отправителю, так и к получателю, то есть к

клиенту или серверу, в зависимости от того, кто посылает, а кто получает

объект.

7.1 Поля заголовка объекта.

Поля заголовка объекта (Entity-header fields) определяют опциональную

метаинформацию о теле объекта (entity-body) или, если тело отсутствует, о

ресурсе, идентифицированном запросом.

entity-header = Allow | Content-Base | Content-Encoding | Content-

Language | Content-Length | Content-Location | Content-MD5 | Content-

Range | Content-Type | ETag | Expires | Last-Modified | extension-

header

extension-header = message-header

Механизм расширения полей заголовка позволяет вводить дополнительные

поля заголовка объекта (entity-header fields) не изменяя протокол, но эти

поля могут быть и не распознаны получателем. Получатель должен игнорировать

нераспознанные поля заголовка, а прокси-сервер должен просто пересылать их

без изменений.

7.2 Тело объекта.

Тело объекта (если оно присутствует) посылается с HTTP запросом или

ответом и имеет формат и кодирование, определяемое полями заголовка объекта

(entity-header fields).

entity-body = *OCTET

Тело объекта (entity-body) представлено в сообщении только тогда,

когда присутствует тело сообщения (message-body). Тело объекта (entity-

body) получается из тела сообщения (message-body) декодированием любого

кодирования передачи, указанного в поле Transfer-Encoding, которое может

быть применено для гарантирования безопасной и правильной передачи

сообщения.

7.2.1 Тип.

Когда в сообщении содержится тело объекта (entity-body), тип данных

этого тела определяется полями заголовка Content-Type и Content-Encoding.

Они определяют двухуровневую упорядоченную модель кодирования:

entity-body := Content-Encoding( Content-Type( data ) )

Тип содержимого (Content-Type) определяет медиатип лежащих в основе

данных. Кодирование содержимого (Content-Encoding) может использоваться для

указания любых дополнительных кодирований содержимого, примененных к данным

(обычно с целью сжатия). Кодирование содержимого (Content-Encoding)

является свойством запрошенного ресурса. По умолчанию никакого кодирования

не задано.

В любое HTTP/1.1 сообщение, содержащее тело объекта (entity-body)

включает поле заголовка Content-Type, определяющее медиатип этого тела. В

том и только в том случае, когда медиатип не указан в поле Content-Type,

получатель може попытаться самостоятельно определить медиатип, проверяя

содержимое и/или расширение (расширения) в URL, используемого для

идентификации ресурса. Если медиатип остался нераспознан, получателю

следует обрабатывать его как тип "application/octet-stream".

7.2.2 Длина.

Длина тела объекта (entity-body) - это длина тела сообщения (message-

body), полученного после декодирования всех кодирований передачи.

8 Соединения (Connections).

8.1 Постоянные соединения (Persistent Connections).

8.1.1 Цель.

До введения в протокол постоянных соединений для запроса каждого URL

устанавливалось отдельное TCP соединение, что увеличивало нагрузку на HTTP

сервера и вызывало перегрузку сетей. Использование встроенных изображений и

других связанных данных часто требует от клиента инициировать несколько

запросов к одному серверу за короткий промежуток времени.

Постоянные HTTP соединения имеют ряд преимуществ:

- Открытие и закрытие меньшего количества TCP соединений экономит время

центрального процессора и память, используемую для управляющих блоков

протокола TCP.

- HTTP запросы и ответы может быть конвейеризованы в соединении.

Конвейерная обработка позволяет клиенту делать несколько запросов не

ожидая ответа на каждый, позволяет пользоваться единственным TCP

соединением более эффективно, с меньшими затратами времени.

- Загрузка сети уменьшается с уменьшением числа пакетов, необходимых для

открытия TCP соединений, и, следовательно, предоставляет протоколу TCP

достаточно времени для определения состояния перегрузки сети.

- HTTP может развиваться более элегантно; так как ошибки можно сообщать

без закрытия TCP соединения в качестве штрафа. Клиенты, использующие

будущие версии HTTP могли бы оптимистично пробовать новые возможности,

а при связи со старым сервером, повторять запрос, используя старую

семантику после сообщения об ошибке.

8.1.2 Общее описание.

Значительное отличие HTTP/1.1 от ранних версий HTTP состоит в том, что

постоянные соединения являются заданным по умолчанию поведением любого HTTP

соединения. То есть если не обозначено иного, клиент может считать, что

сервер поддержит постоянное соединение.

Постоянные соединения обеспечивают механизм, согласно которому клиент

и сервер могут сообщить о разрыве TCP соединения. Это сигнализируется путем

использования поля заголовка Connection.

8.1.2.1 Обсуждение (Negotiation).

HTTP/1.1 сервер в праве считать, что HTTP/1.1 клиент не поддерживает

постоянное соединение, если посланный в запросе заголовок Connection

содержит лексему соединения (connection-token) "close". Если сервер решает

закрыть соединение немедленно после посылки ответа, то ему необходимо

послать заголовок Connection, который содержит лексему соединения

(connection-token) "close".

HTTP/1.1 клиент долженждать закрытие соединения, но должен держать его

открытым на основании того, содержит ли ответ сервера заголовок Connection

с лексемой соединения "close". В случае, если клиент не хочет поддерживать

соединение для последующих запросов, ему надлежит послать заголовок

Connection, содержащий лексему соединения "close".

Если клиент или сервер посылает лексему закрытия соединения "close" в

заголовке Connection, то запрос становится последним в соединении.

Чтобы соединение оставалось постоянным, все сообщения, передаваемые по

нему должны иметь самоопределенную (self-defined) длину (то есть, не

определяемую закрытием соединения).

8.1.2.2 Конвейерная обработка (Pipelining).

Клиент, который поддерживает постоянные соединения умеет производить

"конвейерную обработку" запросов (то есть посылать несколько запросов не

ожидая ответа на каждый из них). Сервер должен послать ответы на эти

запросы в том же самом порядке, в каком были получены запросы.

Клиенты, которые поддерживают постоянные соединения и производят

конвейерную обработку немедленно после установления соединения, должны быть

готовы повторить соединение, если первая попытка конвейерной обработки дала

сбой. Если клиент производит такой повтор, он не должен производить

конвейерную обработку прежде чем узнает, что соединение постоянно. Также

клиенты должны быть готовы повторить запросы, если сервер закрывает

соединение перед посылкой всех соответствующих ответов.

8.1.3 Прокси-сервера (Proxy Servers).

Очень важно, чтобы прокси-сервера правильно реализовывали свойства

полей заголовка Connection.

Прокси-сервер должен сообщать о постоянных соединениях отдельно своим

клиентам и отдельно первоначальным серверам (или другим прокси-серверам),

которые с ним соединены. Каждое постоянное соединение применяется только к

одной транспортной связи.

Прокси-сервер не должен устанавливать постоянных соединений с HTTP/1.0

клиентом.

8.1.4 Практические соображения.

Сервера обычно имеют некоторое значение времени ожидания, после

которого они не поддерживают неактивное соединение. Прокси-сервера могут

выставлять его значение более высоким, так как, вероятно, клиент сделает

больше соединений через этот же сервер. Использование постоянных соединений

не вводит никаких ограничений на продолжительность времени ожидания как для

клиента, так и для сервера.

Когда у клиента или сервера истекло время ожидания, ему необходимо

произвести закрытие транспортного соединения. Как клиентам, так и серверам

надлежит постоянно наблюдать за другой стороной на предмет закрытия

соединения и отвечать соответственно. Если клиент или сервер не сразу

обнаруживает закрытие соединения другой стороной, то это вызывает не

оправданную трату ресурсов сети.

Клиент, сервер, или прокси-сервер в праве закрыть транспортное

соединение в любое время. Например, клиент может начать посылать новый

запрос в то время, когда сервер решает закрыть "бездействующее" соединение.

С точки зрения сервера, соединение закрывается, в то время как оно было

неактивно, но с точки зрения клиента, запрос произошел.

Это означает, что клиенты, серверы, и прокси-серверы должны быть в

состоянии обрабатывать асинхронные события закрытия. Программному

обеспечению клиента следует вновь открыть транспортное соединение и

повторно передать прерванный запрос без взаимодействия с пользователем,

если метод запроса идемпотентен; другие методы не должны быть повторены

автоматически, хотя агенты пользователя могут предложить оператору

повторить запрос.

Однако это автоматического повтора производить не следует, если сбой

происходит уже во втором запросе.

Серверам всегда следует отвечать по крайней мере на один запрос в

соединении, если это возможно. Серверам не следует разрывать соединение в

середине передачи ответа, если не предполагается сетевого или клиентского

отказа.

8.2 Требования к передаче сообщений.

Общие требования:

- HTTP/1.1 серверам следует поддерживать постоянные соединения и

использовать механизмы управления потоком данных TCP в целях

уменьшения временных перегрузок, вместо закрытия соединений, которые,

как ожидается, могут быть повторно использованы клиентами. Последняя

методика может усиливать сетевую загрузку.

- HTTP/1.1 (или более поздним) клиентам, посылающим тело сообщения

(message-body) следует контролировать сетевое соединение на предмет

ошибок во время передачи запроса. Если клиент обнаруживает ошибку, ему

следует немедленно прекратить передачу тела сообщения. Если тело

посылается с использованием кодирования "по кускам" ("chunked"), то

кусок нулевой длины, и пустой завершитель могут использоваться для

индикации преждевременного конца сообщения. Если телу предшествовал

заголовок Content-Length, клиент должен закрыть соединение.

- HTTP/1.1 (или более поздний) клиент должен быть готов принять ответ с

кодом состояния 100 (Продолжать, Continue), предшествующий основному

ответу.

- HTTP/1.1 (или более поздний) сервер, который получает запрос от

HTTP/1.0 (или более раннего) клиента не должен отвечать кодом

состояния 100 (Продолжать, Continue); ему следует либо ждать пока

запрос будет выполнен обычным образом (то есть без использования

прерванного запроса), либо преждевременно закрыть соединение.

- После получения метода, подчиненного этим требованиям, от HTTP/1.1

(или более позднего) клиента, HTTP/1.1 (или более поздний) сервер

должен либо ответить кодом состояния 100 (Продолжать, Continue) и

продолжать чтение входного потока, либо ответить кодом состояния

ошибки. Если сервер ответил кодом состояния ошибки, то он может либо

закрыть транспортное соединение (TCP), либо продолжать читать и

отбрасывать оставшуюся часть запроса. Он не должен выполнять

запрошенный метод, если возвратил код состояния ошибки.

Клиентам следует помнить номер версии HTTP, используемой сервером по

крайней мере в последний раз; если HTTP/1.1 клиент встречал HTTP/1.1 или

более поздний ответ от сервера, и видит закрытие соединения перед

получением какого-либо кода состояния от сервера, клиенту следует повторить

запрос без взаимодействия с пользователем, если метод запроса идемпотентен;

другие методы не должны быть повторены автоматически, хотя агенты

пользователя могут предложить оператору повторить запрос. Если клиент

повторяет запрос, то он

- должен сначала послать поля заголовка запроса, а затем

- должен либо ожидать ответа сервера с кодом 100 (Продолжать, Continue)

и затем продолжать, либо с кодом состояния ошибки.

Если HTTP/1.1 клиент не встречал ответа сервера версии HTTP/1.1 или

более поздней, то ему следует считать, что сервер реализует HTTP/1.0 или

более старый протокол и не использовать ответы с кодом состояния 100

(Продолжать, Continue). Если в такой ситуации клиент видит закрытие

соединения перед получением какого-либо ответа с кодом состояния от

сервера, то ему следует повторить запрос. Если клиент повторяет запрос к

этому HTTP/1.0 серверу, то он должен использовать следующий алгоритм

"двоичной экспоненциальной задержки" ("binary exponential backoff"), чтобы

гарантировать получение надежного ответа:

1. Инициировать новое соединение с сервером.

2. Передать заголовки запроса (request-headers).

3. Инициализировать переменную R примерным временем передачи информации

на сервер и обратно (например на основании времени установления

соединения), или постоянным значение в 5 секунд, если время передачи

не доступно.

4. Вычислить T = R * (2**N), где N - число предыдущих повторов этого

запроса.

5. Либо дождаться от сервера ответа с кодом ошибки, либо просто выждать T

секунд (смотря что произойдет раньше).

6. Если ответа с кодом ошибки не получено, после T секунд передать тело

запроса.

7. Если клиент обнаруживает, что соединение было закрыто преждевременно,

то ему нужно повторять начиная с шага 1, пока запрос не будет принят,

либо пока не будет получен ошибочный ответ, либо пока у пользователя

не кончится терпение и он не завершит процесс повторения.

Независимо от того, какая версия HTTP реализована сервером, если

клиент получает код состояния ошибки, то он

- не должен продолжать и

- должен закрыть соединение, если он не завершил посылку сообщения.

HTTP/1.1 (или более позднему) клиенту, который обнаруживает закрытие

соединения после получения ответа с кодом состояния 100 (Продолжать,

Continue), но до получения ответа с другим кодом состояния, следует

повторить запрос, но уже не ожидать ответа с кодом состояния 100

(Продолжать, Continue).

9 Определения методов.

Множество общих для HTTP/1.1 методов приводится ниже. Хотя это

множество может быть расширено, нельзя считать, что дополнительные методы

имеют одиннаковую семантику, если они являются расширениями разных клиентов

и серверов.

Поле заголовка запроса Host должно сопровождать все HTTP/1.1 запросы.

9.1 Безопасные и идемпотентные методы.

9.1.1 Безопасные методы.

Программистам следует понимать, что программное обеспечение при

взаимодействии с Интернетом представляет пользователя, и программе следует

информировать пользователя о любых действиях, которые он может произвести,

но которые могут иметь непредсказуемое значение для него или других лиц.

В частности было принято соглашение, что методы GET и HEAD никогда не

должны иметь иного значения, кроме загрузки (retrieval). Эти методы следует

рассматривать как "безопасные". Это позволяет агенту пользователя

представлять другие методы, такие как POST, PUT и DELETE, таким образом,

чтобы пользователь был проинформирован о том, что он запрашивает выполнение

потенциально опасного действия.

Естественно невозможно гарантировать, что сервер не генерирует

побочных эффектов в результате выполнения запроса GET; фактически,

некоторые динамические ресурсы содержат такую возможность. Важное различие

здесь в том, что не пользователь запрашивает побочные эффекты, и,

следовательно, пользователь не может нести ответственность за них.

9.1.2 Идемпотентные методы.

Методы могут также обладать свойством "идемпотентности"

("idempotence") в том смысле, что побочные эффекты от N > 0 идентичных

запросов такие же, как от одиночного запроса (за исключение ошибок и

проблем устаревания). Методы GET, HEAD, PUT и DELETE обладают данным

свойством.

9.2 OPTIONS.

Метод OPTIONS представляет запрос информации об опциях соединения,

Страницы: 1, 2, 3