Протокол HTTP 1.1

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

ответов. Протокол HTTP/1.1 включает ряд элементов, предлагаемых как

возможная реализация кэширования. Так как эти элементы отличаются от других

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

будет описать основы кэширования в HTTP отдельно от детализированных

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

Цель кэширования в HTTP/1.1 состоит в том, чтобы устранить потребность

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

ответов в других случаях. Кэширование уменьшает число пересылок информации

по сети, требуемых для многих действий; мы используем для этой цели

механизм "устаревания" ("expiration"). Кэширование снижает требования к

пропускной способности сети; мы используем для этой цели механизм "проверки

достоверности" ("validation").

Требования эффективности, доступности, и раздельного функционирования

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

план. Протокол HTTP/1.1 позволяет первоначальным серверам, кэшам, и

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

как непрозрачное функционирование может ввести в заблуждение неопытных (non-

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

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

прозрачность ослаблялась

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

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

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

вызывается кэшем или клиентом

Таким образом протокол HTTP/1.1 предоставляет следующие важные

элементы:

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

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

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

агенту пользователя явно запрашивать непрозрачное функционирование и

управлять им.

3. Возможности протокола, которые позволяют кэшу присоединять к ответам

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

прозрачности не сохранен.

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

обнаружить любое потенциальное ослабление семантической прозрачности.

Реализатор сервера, кэша или клиента может столкнуться с проблемами,

явно не обсужденными в этой спецификации. Если решение может воздействовать

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

сторону сохранения прозрачности, если осторожный и полный анализ не

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

13.1 Общая информация о кэшировании.

13.1.1 Правильность кэша.

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

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

следующих условий:

1. Он был проверен на эквивалентность ответу, который возвратил

первоначальный сервер, повторно подтверждая достоверность;

2. Он "достаточно свеж" ("fresh enough"). По умолчанию это означает,

что он удовлетворяет наименьшему из ограничительных требований

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

сервером, то это - требование свежести единственно первоначального

сервера.

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

первоначальный сервер нарушен.

4. Он соответствует сообщению ответа с кодом состояния 304 (не

модифицирован, Not Modified), 305 (используйте прокси-сервер, Use

Proxy), или ошибочному ответу (4xsx или 5xx).

Если кэш не может связаться с первоначальным сервером, то правильному

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

обслужен из кэша; иначе необходимо возвратить ошибку или предупредить о

том, что имеется отказ связи.

Если кэш получает ответ (либо весь ответ, либо ответ с кодом состояния

304 (не модифицирован, Not Modified)), который может быть нормально передан

запрашивающему клиенту, и полученный ответ устарел, то кэшу следует

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

(Предупреждение) (но не удаляя существующие заголовки Warning). Кэшу не

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

тот ответ устарел при передаче; это могло бы привести к бесконечному циклу.

Агент пользователя, который получает просроченный ответ без Warning может

показать пользователю предупреждение.

13.1.2 Предупреждения.

Всякий раз, когда кэш возвращает ответ, который не является ни

непосредственным (first-hand), ни "достаточно свежим" (в смысле условия 2

раздела 13.1.1), он должен присоединить предупреждение об этом, используя

заголовок ответа Warning. Это предупреждение позволяет клиентам

предпринимать соответствующие действия.

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

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

ошибочных кодов состояния, отличает эти ответы от истинных отказов.

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

ответа. Это означает, что предупреждения могут быть переданы HTTP/1.0 кэшам

без опасений; такие кэши просто передадут предупреждение дальше как

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

Предупреждения - это предопределенные числа от 0 до 99. Эта

спецификация определяет коды, и значения каждого определенного в настоящее

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

самостоятельные действия в некоторых (но не во всех) случаях.

Предупреждения также содержат текст предупреждения. Текст может быть

на любом соответствующем естественном языке (возможно на основании

заголовков Accept клиента), и включать опциональную индикацию используемого

набора символов.

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

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

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

тоже предупреждение как к английским текстам, так и к баскским.

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

практически не целесообразно или не приемлемо показать все из них

пользователю. Эта версия HTTP не определяет строгих приоритетных правил для

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

предлагает некоторую эвристику.

13.1.3 Механизмы управления кэшем (Cache-control Mechanisms).

Основные механизмы кэша в HTTP/1.1 (указанные сервером время

устаревания (expiration time) и указатель достоверности (validator)) -

неявные директивы кэшу. Возможны случаи, в которых сервер или клиент должен

обеспечить явные директивы HTTP кэшу. Мы используем для этой цели заголовок

Cache-Control.

Заголовок Cache-Control позволяет клиенту или серверу передавать ряд

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

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

если имеется очевидный конфликт между значениями заголовка, то должна

применяться наиболее ограничивающая интерпретация (то есть та, которая,

наилучшим образом сохранит семантическую прозрачность). Однако в некоторых

случаях директивы управления кэшем (Cache-Control) явно указывают

ослабление уровня семантической прозрачности (например, "максимально-

просроченный" ("max-stale") или "общий" ("public")).

13.1.4 Явные предупреждения агента пользователя.

Многие агенты пользователя делают возможным для пользователей отменить

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

пользователю указать такое поведение, при котором кэшированные объекты

(даже явно просроченные) никогда не проверяются на достоверность (are never

validated). Либо агент пользователя мог бы добавлять "Cache-Control: max-

stale=3600" к каждому запросу. Пользователю следует явно запрашивать как

непрозрачное поведение, так и поведение, которое неверно приводит к

неэффективному кэшированию.

Если пользователь отменил основные механизмы кэширования, агент

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

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

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

отображаемый объект просрочен). Так как протокол обычно позволяет агенту

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

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

только диалоговым окном, но и иконкой (например, изображением гниющей рыбы)

или другим визуальным индикатором.

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

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

непрерывно индицировать (например, изображением горящей купюры) то, что

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

времени ожидания.

13.1.5 Исключения из правил и предупреждений.

В некоторых случаях, оператор кэша может сконфигурировать его таким

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

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

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

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

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

заголовок Warning). Это позволяет программному обеспечению клиента

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

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

получения непосредственного (first-hand) или свежего ответа. По этой

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

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

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

13.1.6 Контролируемое клиентом поведение.

В то время как первоначальный сервер (и меньшей степени промежуточные

кэши с их вкладом в возраст ответа) является первичным источником

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

необходимо управлять решением кэша о том, возвращать ли кэшированный ответ,

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

директив заголовка управления кэшем (Cache-Control).

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

ответа, который он желает получить; указывая ноль он вынуждает кэш(и)

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

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

этих опции увеличивают ограничения на поведение кэшей, и, таким образом, не

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

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

некоторого определенного срока. Это ослабляет ограничения на кэши, и, таким

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

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

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

связи.

13.2 Модель устаревания.

13.2.1 Устаревание, указанное сервером.

HTTP кэширование работает лучше всего тогда, когда кэши могут

полностью избежать запросов к первоначальному серверу. Первичный механизм

избавления от запросов - когда сервер происхождения обеспечивает явное

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

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

свежий ответ без контакта с сервером.

Мы ожидаем, что серверы будут назначать явное время устаревания

ответов будучи убеждены, что объект, вероятно, не будет изменен

семантически значимым способом до истечения этого времени. Это обычно

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

выбрано сервером.

Механизм устаревания применяется только к ответам, полученным из кэша

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

клиенту.

Если первоначальный сервер хочет вынудить семантически прозрачный кэш

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

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

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

последующих запросов.

Если первоначальный сервер хочет вынудить любой HTTP/1.1 кэш,

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

запроса, он должен использовать директиву Cache-Control "must-revalidate".

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

Expires, так и директиву max-age заголовка Cache-Control.

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

пользователя обновить отображенную на экране информацию или перезагрузить

ресурс; оно имеет значение только в применении к механизмам кэширования, и

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

когда происходит новый запрос этого ресурса.

13.2.2 Эвристическое устаревание.

Так как первоначальные серверы не всегда указывают явное время

устаревания, то HTTP кэши обычно назначают эвристическое время устаревания,

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

как время последней модификации (Last-Modified)) для оценки вероятного

времени устаревания. Спецификация HTTP/1.1 не обеспечивает специфических

алгоритмов, но налагает ограничения в виде оценки наихудшей погрешности их

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

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

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

возможно часто.

13.2.3 Вычисление возраста.

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

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

Хосты, которые используют HTTP, а в особенности хосты, на которых

выполняются первоначальные серверы и кэши, должны использовать NTP или

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

временем.

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

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

HTTP/1.1 использует заголовок ответа Age для передачи информации о

возрасте между кэшами. Значение заголовка Age является оценкой отправителя

количества времени, прошедшего с момента, когда ответ был сгенерирован на

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

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

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

В сущности, значение Age - сумма времен которые ответ находился в

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

сети.

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

способами:

1. "Сейчас" минус date_value, если локальные часы хорошо

синхронизированы с часами первоначального сервера. Если результат

отрицателен, результат заменяется нулем.

2. age_value, если все кэши по пути ответа реализуют HTTP/1.1.

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

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

Corrected_received_age = max("сейчас" - date_value, age_value)

и пока часы у нас синхронизированы, а все кэши на пути ответа -

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

Эта поправка применяется в каждом HTTP/1.1 кэше по пути следования

ответа, так что если на пути встретится HTTP/1.0 кэш, то полученный возраст

будет вычислен правильно, если часы этого кэша хорошо синхронизированы.

Из-за задержек, обусловленных сетью, некоторое значительное время

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

когда он был получен следующим внешним кэшем или клиентом. Игнорирование

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

Если запрос, который привел к возвращенному значению Age, должно быть

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

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

запрос. Таким образом, когда получено значение Age, оно должно быть

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

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

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

corrected_initial_age = corrected_received_age + ("сейчас" - request_time)

Где "request_time" - время (согласно локальным часам), когда был

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

Резюме алгоритма вычисления возраста полученного кэшем ответа:

/* * age_value * - это значение Age: заголовок, полученный кэшем в * этом

ответе. * date_value * - это значение Date первоначального сервера:

заголовок * request_time * - это (локальное) времея, когда кэш сделал

запрос, * который вызвал этот кэшируемый ответ * response_time * - это

(локальное) время, когда кэш получил ответ * now * - текущее (локальное)

время */ apparent_age = max(0, response_time - date_value);

corrected_received_age = max(apparent_age, age_value); response_delay =

response_time - request_time; corrected_initial_age =

corrected_received_age + response_delay; resident_time = now -

response_time; current_age = corrected_initial_age + resident_time;

Когда кэш посылает ответ, он должен добавить к corrected_initial_age

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

передать этот общий возраст, используя заголовок Age, следующему

получающему кэшу.

13.2.4 Вычисление устаревания.

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

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

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

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

могут представляться в любой форме, подходящей для арифметических действий.

Термин "expires_value" представляет значение заголовка Expires.

Термин "max_age_value" применяется для указания значения числа секунд,

представленного директивой max-age заголовка Cache-Control ответа.

Директива max-age имеет приоритет над Expires. Таким образом если в

ответе присутствует max-age, то вычисления просты:

freshness_lifetime = max_age_value

В других случаях, когда в ответе присутствует Expires, вычисления

таковы:

freshness_lifetime = expires_value - date_value

Ни одно из этих вычислений не уязвимо от рассинхронизирования часов,

так как вся информация поступает от первоначального сервера.

Если ни Expires, ни Cache-Control: max-age не встречаются в ответе, и

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

срок службы, используя эвристику. Если это значение больше 24-х часов, то

кэш должен присоединять Warning 13 к любому ответу, чей возраст больше 24-х

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

Также если ответ имеет время последнего изменения Last-Modified, то

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

более некоторой части временного интервала, прошедшего этого времени.

Типичная значение этой части могло бы быть 10%.

Вычислить, истек ли ответ, совершенно просто:

response_is_fresh = (freshness_lifetime > current_age)

13.2.5 Устранение противоречий в значениях устаревания.

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

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

и того же ресурса.

Если клиент, выполняющий поиск, получает не непосредственный ответ на

запрос, который уже был свежим в его собственном кэше, а заголовок Date в

существующем вхождении кэша более свежий, чем Date нового ответа, то клиент

может игнорировать ответ. Если он игнорирует ответ, то он может повторить

запрос с директивой "Cache-Control: max-age=0", вызывая проверку

первоначальным сервером.

Если кэш имеет два свежих ответа на запрос одного и того же

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

использовать тот из них, у которого заголовок Date более свеж. Такая

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

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

очевидно свежего вхождения кэша.

13.2.6 Устранение противоречий между несколькими ответами.

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

ситуация, когда кеш получает один поток ответов через один набор кэшей, а

другой поток ответов через другой набор кэшей. В таком случае клиент может

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

первоначальный сервер. Мы хотели бы, чтобы клиент использовал наиболее

свежий ответ, даже если ранее полученные ответы все еще очевидно свежи.

Ни метка объекта ни значение устаревания не можгут быть использованы

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

преднамеренно несет более раннее время устаревания. Однако, спецификация

HTTP/1.1 требует передачи заголовков Date в каждом ответе, и значения Date

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

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

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

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

изменений, но включить

Cache-Control: max-age=0

чтобы вынудить промежуточные кэши проверить достоверность их копий

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

Cache-Control: no-cache

чтобы вынудить промежуточные кэши получить новую копию с

первоначального сервера.

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

(или может, если он чрезвычайно предусмотрительный, запросить новый ответ).

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

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

накладываются.

13.3 Модель проверки достоверности (validation model).

Если кэш имеет просроченное вхождение, которое он хотел бы

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

свериться с первоначальным сервером (или с промежуточным кэшем, обладающим

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

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

кэша. Так как мы не хотим оплачивать излишнюю передачу полного ответа,

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

передачу ответа туда и обратно, когда кэшируемое вхождение нас не

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

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

что имеют отношение к "указателям достоверности (validators) кэша". Когда

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

некоторый указатель достоверности (validator), который сохраняется во

вхождении кэша. Когда клиент (агент пользователя или кэш прокси-сервера)

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

включает связанный указатель достоверности (validator) в запрос.

Затем сервер проверяет полученный указатель достоверности (validator)

на соответствие текущему указателю достоверности (validator) объекта, и,

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

состояния (обычно 304 (не модифицирован), не содержащий тела объекта. В

противном случае, он возвращает полный ответ (включая тело объекта). Таким

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

указателя достоверности (validator), и избегаем дополнительной передачи

туда-обратно в случае несоответствия.

В HTTP/1.1, условный запрос выглядит точно также, как нормальный

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

заголовок (который включает указатель достоверности), который неявно

превращает метод (обычно, GET) в условный.

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

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

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

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

достоверности.

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

кэшироваться и обслуживаться из кэша пока не устареет, если это явно не

запрещено директивой Cache-Control. Однако, кэш не может производить

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

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

Библиографический список

|Номер |Название |Авторы |Дата |Статус |Примечания |

|RFC | | | | | |

|822 |STANDARD FOR THE |David H. |August 13,|Proposed |Obsoletes: |

| |FORMAT OF ARPA |Crocker |1982 |Standard |RFC #733 |

| |INTERNET TEXT | | | | |

| |MESSAGES | | | | |

|850 |Standard for |RFC team |June 1983 |Information| |

| |Interchange of USENET| | |al | |

| |Messages | | | | |

|1036 |Standard for |M. |December |Proposed |Obsoletes: |

| |Interchange of USENET|Horton, |1987 |Standard |RFC-850 |

| |Messages |R. Adams | | | |

|1123 |Requirements for |Robert |October |Proposed | |

| |Internet Hosts -- |Braden |1989 |Standard | |

| |Application and | | | | |

| |Support | | | | |

|1738 |Uniform Resource |Tim |December |Proposed | |

| |Locators (URL) |Berners-L|1994 |Standard | |

| | |ee, | | | |

| | |Larry | | | |

| | |Masinter,| | | |

| | | | | | |

| | |Mark | | | |

| | |McCahill | | | |

|1766 |Tags for the |H. |March 1995|Standards | |

| |Identification of |Alvestran| |Track | |

| |Languages |d | | | |

|1808 |Relative Uniform |Roy T. |June 1995 |Proposed | |

| |Resource Locators |Fielding | |Standard | |

|1867 |Form-based File |E. Nebel,|November |Experimenta| |

| |Upload in HTML |L. |1995 |l | |

| | |Masinter | | | |

|1900 |Renumbering Needs |Brian E. |February |Information| |

| |Work |Carpenter|1996 |al | |

| | |, Yakov | | | |

| | |Rekhter | | | |

|1945 |Hypertext Transfer |T. |May 1996 |Information| |

| |Protocol -- HTTP/1.0 |Berners-L| |al | |

| | |ee, R. | | | |

| | |Fielding | | | |

| | |, H. | | | |

| | |Frystyk | | | |

|1950 |ZLIB Compressed Data |P. |May 1996 |Information| |

| |Format Specification |Deutsch, | |al | |

| |version 3.3 |J-L. | | | |

| | |Gailly | | | |

|1952 |GZIP file format |P. |May 1996 |Information| |

| |specification version|Deutsch | |al | |

| |4.3 | | | | |

|2048 |Multipurpose Internet|N. Freed,|November |Best |Obsoletes: |

| |Mail Extensions |J. |1996 |Current |1521, 1522, |

| |(MIME) Part Four: |Klensin, | |Practice |1590 |

| |Registration |J. Postel| | | |

| |Procedures | | | | |

|2068 |Hypertext Transfer |R. |January |Standards | |

| |Protocol -- HTTP/1.1 |Fielding,|1997 |Track | |

| | | | | | |

| | |J. | | | |

| | |Gettys, | | | |

| | |J. Mogul,| | | |

| | |H. | | | |

| | |Frystyk, | | | |

| | |T. | | | |

| | |Berners-L| | | |

| | |ee | | | |

|2069 |An Extension to HTTP |J. |January |Standards | |

| |: Digest Access |Franks, |1997 |Track | |

| |Authentication |P. | | | |

| | |Hallam-Ba| | | |

| | |ker, J. | | | |

| | |Hostetler| | | |

| | |, P. | | | |

| | |Leach, A.| | | |

| | |Luotonen,| | | |

| | |E. Sink, | | | |

| | |L. | | | |

| | |Stewart | | | |

-----------------------

[pic]

[pic]

[pic]

Страницы: 1, 2, 3, 4, 5, 6, 7