Internet Engineering Task Force (IETF)
RFC 6455
分類 Standards Track
ISSN 2070-1721
編集 I. Fette, Google, Inc.;
A. Melnikov, Isode Ltd.
発行 2011 年 12 月

WebSocket Protocol

要約

WebSocket Protocol は、制御された環境下で信頼できないコードを実行しているクライアントと,そのコードからの通信に対するオプトインを備えるリモート­ホストとの間の双路通信を可能にする。 利用されるセキュリティ­モデルは、ウェブ­ブラウザ間で共通して用いられている,生成元( origin )に基づくセキュリティ­モデルである。 プロトコルは、 TCP の上に重ねられる, opening ハンドシェイク, および後続の基本的なメッセージ フレーミングからなる。 この技術の目標は、サーバとの双路通信を必要とする,ブラウザに基づくアプリケーションのために、複数の HTTP 接続の open (例えば, XMLHttpRequest や <iframe> と長いポーリングを併用するものなど)に依拠しない仕組みを提供することである。 The WebSocket Protocol enables two-way communication between a client running untrusted code in a controlled environment to a remote host that has opted-in to communications from that code. The security model used for this is the origin-based security model commonly used by web browsers. The protocol consists of an opening handshake followed by basic message framing, layered over TCP. The goal of this technology is to provide a mechanism for browser-based applications that need two-way communication with servers that does not rely on opening multiple HTTP connections (e.g., using XMLHttpRequest or <iframe>s and long polling).

このメモの位置付け

これは、 Internet Standards Track 文書である。 This is an Internet Standards Track document.

この文書は、 IETF よる成果物であり, IETF コミュニティの合意を表現するものである。 それは、公開の評価を受け, IESG から発行が承認されたものである。 Internet 標準についての更なる情報は RFC5741 2 節 に見られる。 This document is a product of the Internet Engineering Task Force (IETF). It represents the consensus of the IETF community. It has received public review and has been approved for publication by the Internet Engineering Steering Group (IESG). Further information on Internet Standards is available in Section 2 of RFC 5741.

この文書の現在の位置付け, 正誤表, フィードバックの仕方についての情報は、 http://www.rfc-editor.org/info/rfc6455 から得られる。 Information about the current status of this document, any errata, and how to provide feedback on it may be obtained at http://www.rfc-editor.org/info/rfc6455.

著作権の告知

Copyright (c) 2011 IETF Trust and the persons identified as the document authors. All rights reserved.

この文書は、その発行の日付から有効な、 BCP 78, および IETF Trust の IETF Documents に対する Legal Provisions Relating の対象になる( http://trustee.ietf.org/license-info )。 これらの文書には,この文書に関するあなたの権利と制約条項が述べらているので、入念に査読されたし。 この文書から取り出された Code Components は、 Trust Legal Provisions の Section 4.e に述べられるように, Simplified BSD License テキストを含んでいなければならず、 Simplified BSD License に述べられるように,無保証で提供される。 This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (http://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Simplified BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Simplified BSD License.

1. 導入

1.1. 背景

この節は参考である。 _This section is non-normative._

歴史的に、クライアント↔サーバ間の双方向­通信を必要とする ウェブ アプリケーション(例えば,インスタントメッセンジャや, ゲームアプリケーション)の作成においては、サーバから更新をポーリングするために,上流への通知を別個の HTTP コールとして送信する間、 HTTP の濫用を要していた [RFC6202] Historically, creating web applications that need bidirectional communication between a client and a server (e.g., instant messaging and gaming applications) has required an abuse of HTTP to poll the server for updates while sending upstream notifications as distinct HTTP calls [RFC6202].

これは様々な問題を引き起こす: This results in a variety of problems:

  • サーバは、クライアントのそれぞれに対し,多数の下層 TCP 接続の利用を強いられる: クライアントへの情報の送信に一つ,着信メッセージのそれぞれに新たなものを一つずつ。 The server is forced to use a number of different underlying TCP connections for each client: one for sending information to the client and a new one for each incoming message.
  • クライアントからサーバへのメッセージのそれぞれに HTTP ヘッダが含まれるため、伝送路プロトコルのオーバーヘッドが高くなる。 The wire protocol has a high overhead, with each client-to-server message having an HTTP header.
  • クライアント側スクリプトは、返信を追跡するために,発信­接続から着信­接続への対応付けを維持管理しなければならない。 The client-side script is forced to maintain a mapping from the outgoing connections to the incoming connection to track replies.

より単純な解決策は、両方向のトラフィックのために,単独の TCP 接続を利用するものになるであろう。 これが、 WebSocket Protocol が提供するものである。 それは, WebSocket API [WSAPI] との併用により、ウェブ­ページからリモート­サーバへの双路­通信のための, HTTP ポーリングに代わるものを提供する。 A simpler solution would be to use a single TCP connection for traffic in both directions. This is what the WebSocket Protocol provides. Combined with the WebSocket API [WSAPI], it provides an alternative to HTTP polling for two-way communication from a web page to a remote server.

同じ技法は様々なウェブ­アプリケーションにも利用できる: ゲーム, 相場表示機, 複数­利用者から同時編集可能なアプリケーション, サーバ側のサービスがリアルタイムに反映される利用者インタフェース,等々。 The same technique can be used for a variety of web applications: games, stock tickers, multiuser applications with simultaneous editing, user interfaces exposing server-side services in real time, etc.

WebSocket Protocol は、現存の通信基盤からの利点(プロキシ, フィルタリング, 認証)を得るために HTTP をトランスポート層に利用している,既存の双方向­通信­技術に、なり代わるものを目指して設計されている。 HTTP には元々,双方向­通信の用途は想定されていないので(更なる論は [RFC6202] を見よ)、その種の技術は,効率性と信頼性のトレードオフとして実装されていた。 WebSocket Protocol は、現存の HTTP 通信基盤の環境下における,既存の双方向 HTTP 技術の目標に取り組むものである。 そのようなわけで、現在の環境に固有の 多少の複雑さも伴うことにはなるが、それは、 HTTP のポート 80 と 443 を通して働くように,加えて HTTP プロキシや中継点をサポートするように設計されている。 しかしながら,その設計は WebSocket を HTTP に限定するものではなく、将来の実装はプロトコル全体を再発明することなく,専用のポートを通した,より単純なハンドシェイクを利用するものにもなり得る。 この最後の点は、対話的メッセージングのトラフィック パターンが標準の HTTP のトラフィックに近似しないものであり,一部のコンポーネントにおいては過度の負荷を誘引し得ることから、重要である。 The WebSocket Protocol is designed to supersede existing bidirectional communication technologies that use HTTP as a transport layer to benefit from existing infrastructure (proxies, filtering, authentication). Such technologies were implemented as trade-offs between efficiency and reliability because HTTP was not initially meant to be used for bidirectional communication (see [RFC6202] for further discussion). The WebSocket Protocol attempts to address the goals of existing bidirectional HTTP technologies in the context of the existing HTTP infrastructure; as such, it is designed to work over HTTP ports 80 and 443 as well as to support HTTP proxies and intermediaries, even if this implies some complexity specific to the current environment. However, the design does not limit WebSocket to HTTP, and future implementations could use a simpler handshake over a dedicated port without reinventing the entire protocol. This last point is important because the traffic patterns of interactive messaging do not closely match standard HTTP traffic and can induce unusual loads on some components.

1.2. プロトコルの概観

この節は参考である。 _This section is non-normative._

このプロトコルは、ハンドシェイクおよびデータ転送の,2つのパートからなる: The protocol has two parts: a handshake and the data transfer.

次のような形のクライアントからのハンドシェイクに対し: The handshake from the client looks as follows:

GET /chat HTTP/1.1
Host: server.example.com
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Origin: http://example.com
Sec-WebSocket-Protocol: chat, superchat
Sec-WebSocket-Version: 13

サーバからのハンドシェイクは次のような形をとる: The handshake from the server looks as follows:

HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=
Sec-WebSocket-Protocol: chat

クライアントからの先頭行は Request-Line 形式に従う。 サーバからの先頭行は Status-Line 形式に従う。 Request-Line と Status-Line の生成規則は [RFC2616] にて定義される。 The leading line from the client follows the Request-Line format. The leading line from the server follows the Status-Line format. The Request-Line and Status-Line productions are defined in [RFC2616].

いずれの場合も,先頭行の後に順序のない一連の HTTP ヘッダが続く。 これらのヘッダの意味は、この文書の 4 節 にて指定される。 クッキー [RFC6265] などの追加のヘッダも在ってよい。 ヘッダの形式と その構文解析法は, [RFC2616] にて定義される。 An unordered set of header fields comes after the leading line in both cases. The meaning of these header fields is specified in Section 4 of this document. Additional header fields may also be present, such as cookies [RFC6265]. The format and parsing of headers is as defined in [RFC2616].

クライアントとサーバの両者がそれぞれのハンドシェイクを送信した後,ハンドシェイクが成功したならば、データ転送パートが開始される。 これは、それぞれの側が互いに独立に, 自身の意向によりデータを送信できる,双路­通信チャンネルである。 Once the client and server have both sent their handshakes, and if the handshake was successful, then the data transfer part starts. This is a two-way communication channel where each side can, independently from the other, send data at will.

ハンドシェイクの成功後、クライアントとサーバは,この仕様において “メッセージ” と呼ばれる,概念的な単位で区切られたデータを 相互に転送しあう。 伝送路­上では, 1 個のメッセージは 1 個以上のフレームから構成される。 WebSocket メッセージは特定のネットワーク層フレーミングに対応しなければならないわけではなく、断片化されたメッセージは,中継点において合併/分割され得る。 After a successful handshake, clients and servers transfer data back and forth in conceptual units referred to in this specification as "messages". On the wire, a message is composed of one or more frames. The WebSocket message does not necessarily correspond to a particular network layer framing, as a fragmented message may be coalesced or split by an intermediary.

フレームには種別( type )が結び付けられる。 同じメッセージに属するそれぞれのフレームは,同じ種別のデータを含む。 おおまかに言えば、種別は次のものに分類される:

  • テキスト­データ用途( UTF-8 [RFC3629] テキストとして解釈される),
  • バイナリ­データ用途(それらの解釈はアプリケーションに委ねられる),
  • 制御フレーム用途(アプリケーションのためのデータを運ぶものではなく,接続が close されるべき旨の信号を送るなど,プロトコル­レベルの信号通信のためのもの)。

このバージョンのプロトコルは 6 種類のフレーム種別を定義し,残る 10 種類は将来利用のために予約済みとする。

A frame has an associated type. Each frame belonging to the same message contains the same type of data. Broadly speaking, there are types for textual data (which is interpreted as UTF-8 [RFC3629] text), binary data (whose interpretation is left up to the application), and control frames (which are not intended to carry data for the application but instead for protocol-level signaling, such as to signal that the connection should be closed). This version of the protocol defines six frame types and leaves ten reserved for future use.

1.3. opening ハンドシェイク

この節は参考である。 _This section is non-normative._

opening ハンドシェイクは、単独のポートを,サーバとやりとりする HTTP クライアント, および サーバとやりとりする WebSocket クライアント,のいずれからも利用できるようにするため、 HTTP に基づくサーバ側ソフトウェアや中継点との互換性が保たれることが意図されている。 その目的のため, WebSocket クライアントのハンドシェイクは HTTP Upgrade リクエストになる: The opening handshake is intended to be compatible with HTTP-based server-side software and intermediaries, so that a single port can be used by both HTTP clients talking to that server and WebSocket clients talking to that server. To this end, the WebSocket client's handshake is an HTTP Upgrade request:

GET /chat HTTP/1.1
Host: server.example.com
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Origin: http://example.com
Sec-WebSocket-Protocol: chat, superchat
Sec-WebSocket-Version: 13

[RFC2616] に従い、クライアントから送信されるハンドシェイクの中のヘッダの順序は任意であり,受信されるヘッダの順序は有意ではない。 In compliance with [RFC2616], header fields in the handshake may be sent by the client in any order, so the order in which different header fields are received is not significant.

GET メソッド [RFC2616] の "Request-URI" は, WebSocket 接続の端点† の識別に用いられ、1個の IP アドレスによる複数ドメインにわたるサービス供与,および 単独のサーバによる複数の WebSocket 端点に対するサービス供与が可能になる。 The "Request-URI" of the GET method [RFC2616] is used to identify the endpoint of the WebSocket connection, both to allow multiple domains to be served from one IP address and to allow multiple WebSocket endpoints to be served by a single server.

【† “端点( endpoint )” :クライアント, サーバ(ネットワーク通信の始端, 終端(順不同))の両者をひっくるめて指す総称。 対義語は “中継点( intermediary )”。 端点と同じ意味で,語 “ピア( peer )” も用いられる( HTTP/2 の定義 によれば、この語は,論の主題とされている端点から見た,他方の端点を指すとされている)。 】

クライアントは、 [RFC2616] に従い,利用中のホストがどれなのかクライアントとサーバ間で互いの一致を検証できるように,そのハンドシェイクの Host ヘッダ内にホスト名を内包させる。 The client includes the hostname in the |Host| header field of its handshake as per [RFC2616], so that both the client and the server can verify that they agree on which host is in use.

WebSocket Protocol には、オプションの選択に利用できる,追加のヘッダもある。 このバージョンにて可用な代表的なオプションには、下位プロトコル セレクタ( Sec-WebSocket-Protocol ), クライアントがサポートする拡張のリスト( Sec-WebSocket-Extensions ), Origin ヘッダ,などがある。 Sec-WebSocket-Protocol リクエスト ヘッダは、クライアントが受理し得る下位プロトコル( WebSocket Protocol 層­上の,アプリケーション­レベルのプロトコル)の指示に利用できる。 サーバは、受理­可能なプロトコルのうち,いずれか1個または0個を選択して、そのプロトコルが選択されたことを指示するために,ハンドシェイクにてその値を返す。 Additional header fields are used to select options in the WebSocket Protocol. Typical options available in this version are the subprotocol selector (|Sec-WebSocket-Protocol|), list of extensions support by the client (|Sec-WebSocket-Extensions|), |Origin| header field, etc. The |Sec-WebSocket-Protocol| request-header field can be used to indicate what subprotocols (application-level protocols layered over the WebSocket Protocol) are acceptable to the client. The server selects one or none of the acceptable protocols and echoes that value in its handshake to indicate that it has selected that protocol.

Sec-WebSocket-Protocol: chat

Origin ヘッダ [RFC6454] は、ウェブ­ブラウザの中で WebSocket API を利用するスクリプトによる,権限のないクロス生成元による WebSocket サーバの利用から 保護するために利用される。 サーバには、 WebSocket 接続リクエストを生成するスクリプトの生成元が伝えられる。 サーバは,この生成元からの接続の受理を望まない場合、適切な HTTP エラーコードを送信して,接続を拒否できる。 このヘッダは,ブラウザ­クライアントから送信される。 非ブラウザ­クライアントの場合、その種のクライアントの文脈において意味をなすのであれば,このヘッダが送信されてもよい。 The |Origin| header field [RFC6454] is used to protect against unauthorized cross-origin use of a WebSocket server by scripts using the WebSocket API in a web browser. The server is informed of the script origin generating the WebSocket connection request. If the server does not wish to accept connections from this origin, it can choose to reject the connection by sending an appropriate HTTP error code. This header field is sent by browser clients; for non-browser clients, this header field may be sent if it makes sense in the context of those clients.

最後に、サーバは, WebSocket 接続でない接続を受理しないようにするために、クライアントに対し,クライアントによる WebSocket ハンドシェイクを受信したことを立証しなければならない。 これにより、攻撃者が XMLHttpRequest [XMLHttpRequest] やフォームを用いて巧妙に細工されたパケットを送信して, WebSocket サーバを騙そうとする試みは防止される。 Finally, the server has to prove to the client that it received the client's WebSocket handshake, so that the server doesn't accept connections that are not WebSocket connections. This prevents an attacker from tricking a WebSocket server by sending it carefully crafted packets using XMLHttpRequest [XMLHttpRequest] or a form submission.

ハンドシェイクの受信を立証するためには、サーバは、2つの情報­片をとり,それらを結合して、応答を形成する必要がある。 最初の情報­片は、クライアント ハンドシェイクの Sec-WebSocket-Key ヘッダから得られるものである: To prove that the handshake was received, the server has to take two pieces of information and combine them to form a response. The first piece of information comes from the |Sec-WebSocket-Key| header field in the client handshake:

Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==

このヘッダに対し、サーバはその値(上のヘッダに示されているように base64 符号化 [RFC4648] されたものから,頭部と尾部の空白を取り除いたもの)を取得し,文字列の形をとる もう1つの情報­片 — GUID (大域的一意識別子, Globally Unique Identifier, [RFC4122] ) "258EAFA5-E914-47DA-95CA-C5AB0DC85B11" と連結する。 これは、 WebSocket Protocol を解さないネットワーク端点から利用されることはないものと見込まれている。 この連結結果に対し, SHA-1 ハッシュ( 160 ビット) [FIPS.180-3] をとって,更に base64 符号化( [RFC4648] 4 節 参照)を施したものが、サーバのハンドシェイクにて返される。 For this header field, the server has to take the value (as present in the header field, e.g., the base64-encoded [RFC4648] version minus any leading and trailing whitespace) and concatenate this with the Globally Unique Identifier (GUID, [RFC4122]) "258EAFA5-E914-47DA-95CA-C5AB0DC85B11" in string form, which is unlikely to be used by network endpoints that do not understand the WebSocket Protocol. A SHA-1 hash (160 bits) [FIPS.180-3], base64-encoded (see Section 4 of [RFC4648]), of this concatenation is then returned in the server's handshake.

上の例で具体的に示すなら、 Sec-WebSocket-Key ヘッダの値が "dGhlIHNhbXBsZSBub25jZQ==" であるなら、サーバは:

  1. まず、文字列 "258EAFA5-E914-47DA-95CA-C5AB0DC85B11" を連結して "dGhlIHNhbXBsZSBub25jZQ==258EAFA5-E914-47DA-95CA-C5AB0DC85B11" を形成する。
  2. 次に、その SHA-1 ハッシュをとり,値[ 0xb3 0x7a 0x4f 0x2c 0xc0 0x62 0x4f 0x16 0x90 0xf6 0x46 0x06 0xcf 0x38 0x59 0x45 0xb2 0xbe 0xc4 0xea ]を得る。
  3. 最後に、この値を base64 符号化( [RFC4648] 4 節 参照)して得られる値 "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=" が, Sec-WebSocket-Accept ヘッダの中に返されることになる。

Concretely, if as in the example above, the |Sec-WebSocket-Key| header field had the value "dGhlIHNhbXBsZSBub25jZQ==", the server would concatenate the string "258EAFA5-E914-47DA-95CA-C5AB0DC85B11" to form the string "dGhlIHNhbXBsZSBub25jZQ==258EAFA5-E914-47DA-95CA-C5AB0DC85B11". The server would then take the SHA-1 hash of this, giving the value 0xb3 0x7a 0x4f 0x2c 0xc0 0x62 0x4f 0x16 0x90 0xf6 0x46 0x06 0xcf 0x38 0x59 0x45 0xb2 0xbe 0xc4 0xea. This value is then base64-encoded (see Section 4 of [RFC4648]), to give the value "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=". This value would then be echoed in the |Sec-WebSocket-Accept| header field.

サーバからのハンドシェイクは,クライアントからのハンドシェイクよりもずっと単純になる。 最初の行はステータスコード 101 を伴う HTTP Status-Line になる: The handshake from the server is much simpler than the client handshake. The first line is an HTTP Status-Line, with the status code 101:

HTTP/1.1 101 Switching Protocols

101 以外のどのステータスコードも WebSocket ハンドシェイクが完了しておらず, HTTP の意味論が依然として適用されることを指示する。 ステータスコードの後にヘッダが続く。 Any status code other than 101 indicates that the WebSocket handshake has not completed and that the semantics of HTTP still apply. The headers follow the status code.

ConnectionUpgrade ヘッダが HTTP Upgrade を構成する。 Sec-WebSocket-Accept ヘッダは、サーバが接続を受理する意向があるかどうかを指示する。 もし在るならば,このヘッダは Sec-WebSocket-Key 内に送信されたクライアントの nonce に,定義­済みの GUID を付加してハッシュをとったものを内包していなければならない。 他のすべての値は、サーバによる接続の受理に解釈されてはならない。 The |Connection| and |Upgrade| header fields complete the HTTP Upgrade. The |Sec-WebSocket-Accept| header field indicates whether the server is willing to accept the connection. If present, this header field must include a hash of the client's nonce sent in |Sec-WebSocket-Key| along with a predefined GUID. Any other value must not be interpreted as an acceptance of the connection by the server.

HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=

これらのヘッダは、スクリプトされたページに対し, WebSocket クライアントから検査される。 Sec-WebSocket-Accept の値が予期される値に合致しない場合, または このヘッダを欠いている場合, または HTTP ステータスコードが 101 でない場合、接続は確立されず, WebSocket フレームは送信されないことになる。 These fields are checked by the WebSocket client for scripted pages. If the |Sec-WebSocket-Accept| value does not match the expected value, if the header field is missing, or if the HTTP status code is not 101, the connection will not be established, and WebSocket frames will not be sent.

オプションのヘッダを内包することもできる。 このバージョンのプロトコルにおける主要なオプション ヘッダは、サーバが選択した下位プロトコルを指示する, Sec-WebSocket-Protocol である。 WebSocket クライアントは、自身がハンドシェイクに指定した下位プロトコル値のうちの一つを,サーバが内包したかどうか検証する。 複数の下位プロトコルを話せるサーバは、クライアントのハンドシェイクに基づいて,いずれか 1 つを選択して、そのハンドシェイクに指定しなければならない。 Option fields can also be included. In this version of the protocol, the main option field is |Sec-WebSocket-Protocol|, which indicates the subprotocol that the server has selected. WebSocket clients verify that the server included one of the values that was specified in the WebSocket client's handshake. A server that speaks multiple subprotocols has to make sure it selects one based on the client's handshake and specifies it in its handshake.

Sec-WebSocket-Protocol: chat

サーバは、 [RFC6265] の記述に従って,クッキーに関係するオプション ヘッダを設定することにより、クッキーを 設定する こともできる。 The server can also set cookie-related option fields to _set_ cookies, as described in [RFC6265].

1.4. closing ハンドシェイク

この節は参考である。 _This section is non-normative._

closing ハンドシェイクは, opening ハンドシェイクよりもずっと単純である。 The closing handshake is far simpler than the opening handshake.

いずれのピアも、 closing ハンドシェイクを始めるために,指定された制御の並びを含んだデータを伴う制御フレームを送信できる( 5.5.1 節 にて詳細を述べる)。 その種のフレームが受信された際には、相方のピアは,まだ送信していなければ,応答として Close フレームを送信する。 最初に送信した側のピアは,その制御フレームを受信した際に、それ以上のデータが来ないものとして,接続を安全に close する。 Either peer can send a control frame with data containing a specified control sequence to begin the closing handshake (detailed in Section 5.5.1). Upon receiving such a frame, the other peer sends a Close frame in response, if it hasn't already sent one. Upon receiving _that_ control frame, the first peer then closes the connection, safe in the knowledge that no further data is forthcoming.

接続の close を指示する制御フレームの送信を済ませたピアは、それ以上のデータを送信しない。 接続の close を指示する制御フレームを受信したピアは、それ以降の受信データを破棄する。 After sending a control frame indicating the connection should be closed, a peer does not send any further data; after receiving a control frame indicating the connection should be closed, a peer discards any further data received.

双方のピアが,同時に,このハンドシェイクを起動しても 安全である。 It is safe for both peers to initiate this handshake simultaneously.

closing ハンドシェイクは、特に透過型プロキシや他の中継点が介在する場合において, TCP closing ハンドシェイクが常に信頼し得るエンドツーエンドになるとは限らない意味で、 TCP closing ハンドシェイク( FIN/ACK )を補完することが意図されている。 The closing handshake is intended to complement the TCP closing handshake (FIN/ACK), on the basis that the TCP closing handshake is not always reliable end-to-end, especially in the presence of intercepting proxies and other intermediaries.

Close フレームを送信して,その応答の Close フレームを待機することにより、データが不必要に失われ得る一定の状況を回避できる。 例えば,何らかのプラットフォームにおいて,データが受信キューに残ったままソケットが close された場合、 RST パケットが送信され、読み取り待ちのデータがあったとしても,その RST を受信した側の recv() は失敗する。 By sending a Close frame and waiting for a Close frame in response, certain cases are avoided where data may be unnecessarily lost. For instance, on some platforms, if a socket is closed with data in the receive queue, a RST packet is sent, which will then cause recv() to fail for the party that received the RST, even if there was data waiting to be read.

1.5. 設計理念

この節は参考である。 _This section is non-normative._

WebSocket Protocol は、フレーミングは最小限に留めるべき,という原理に基づいて設計されている(フレーミングは、プロトコルをストリームではなくフレームに基づくものにすること, および Unicode テキストとバイナリのフレームの区別をサポートすること、のためのみに限られている)。 メタデータは、アプリケーション層により, WebSocket の一つ上の層に重ねられることが予期されている — メタデータがアプリケーション層により, TCP の一つ上の層に重ねられるのと同じ様に(例えば, HTTP )。 The WebSocket Protocol is designed on the principle that there should be minimal framing (the only framing that exists is to make the protocol frame-based instead of stream-based and to support a distinction between Unicode text and binary frames). It is expected that metadata would be layered on top of WebSocket by the application layer, in the same way that metadata is layered on top of TCP by the application layer (e.g., HTTP).

概念的には, WebSocket は、ちょうど,次だけを行う TCP の一つ上の層である: Conceptually, WebSocket is really just a layer on top of TCP that does the following:

  • ブラウザのための,ウェブ生成元に基づくセキュリティ­モデルを追加する adds a web origin-based security model for browsers
  • 1個のポート上における複数のサービスを, および 1個の IP アドレス上における複数のホスト名をサポートするための、アドレス法とプロトコル命名の仕組みを追加する adds an addressing and protocol naming mechanism to support multiple services on one port and multiple host names on one IP address
  • TCP の一つ上にフレーミングの仕組みを持つ層を重ねることにより、 TCP の下層の IP パケットの仕組みを(長さ制限を取り払いつつ)取り戻す layers a framing mechanism on top of TCP to get back to the IP packet mechanism that TCP is built on, but without length limits
  • プロキシや他の中継点が介在していても働くように設計された、追加の closing ハンドシェイクを帯域内( in-band )に内包する includes an additional closing handshake in-band that is designed to work in the presence of proxies and other intermediaries

それ以外のものは、 WebSocket には加えられない。 基本的に,それは、 Web の制約下において,ちょうど,スクリプトに生の TCP を露出させるに近いものが意図されている。 また、そのハンドシェイクを妥当な HTTP Upgrade リクエストに仕立て上げることにより, サーバがポートを HTTP サーバと共有できるようにも設計されている。 クライアント↔サーバ間のメッセージングの確立に他のプロトコルを利用することも考えられるが、 WebSocket の意図は、 HTTP や(プロキシなどの)現存の HTTP 通信基盤と共存できるような,それらの通信基盤との併用下において セキュリティ面で TCP に近い安全さを備えつつ、利用法を単純化して,単純な事を単純なままに保つことも念頭に(メッセージ意味論の追加など)、比較的単純なプロトコルを提供する所にある。 Other than that, WebSocket adds nothing. Basically it is intended to be as close to just exposing raw TCP to script as possible given the constraints of the Web. It's also designed in such a way that its servers can share a port with HTTP servers, by having its handshake be a valid HTTP Upgrade request. One could conceptually use other protocols to establish client-server messaging, but the intent of WebSockets is to provide a relatively simple protocol that can coexist with HTTP and deployed HTTP infrastructure (such as proxies) and that is as close to TCP as is safe for use with such infrastructure given security considerations, with targeted additions to simplify usage and keep simple things simple (such as the addition of message semantics).

プロトコルは,拡張可能なように意図されている。 将来のバージョンでは、おそらく,多重化などの追加の概念も導入されることになるものと見込まれている。 The protocol is intended to be extensible; future versions will likely introduce additional concepts such as multiplexing.

1.6. セキュリティ­モデル

この節は参考である。 _This section is non-normative._

WebSocket Protocol がウェブ­ページから利用される際に, WebSocket サーバに接触できるウェブ­ページを制約するため、 WebSocket Protocol では,ウェブ­ブラウザ間で利用されている生成元( origin )モデルが採用されている。 当然, WebSocket Protocol が専用のクライアントから直接的に利用される場合(すなわち,ウェブ­ブラウザを通したウェブ­ページからではなく)、クライアントは任意の生成元­文字列を提供できるので,生成元モデルは有用なものにならない。 The WebSocket Protocol uses the origin model used by web browsers to restrict which web pages can contact a WebSocket server when the WebSocket Protocol is used from a web page. Naturally, when the WebSocket Protocol is used by a dedicated client directly (i.e., not from a web page through a web browser), the origin model is not useful, as the client can provide any arbitrary origin string.

このプロトコルは、必要ならば HTTP サーバがこのプロトコルをオプトインでサポートできるようにしつつ、 SMTP [RFC5321] や HTTP のような現存のプロトコルのサーバとの接続の確立は,失敗するように意図されている。 これは、ハンドシェイクを厳格かつ精巧にして,ハンドシェイクの完成まで 接続に挿入できるデータを制限することにより(したがってサーバへの波及も制限される)、達成される。 This protocol is intended to fail to establish a connection with servers of pre-existing protocols like SMTP [RFC5321] and HTTP, while allowing HTTP servers to opt-in to supporting this protocol if desired. This is achieved by having a strict and elaborate handshake and by limiting the data that can be inserted into the connection before the handshake is finished (thus limiting how much the server can be influenced).

同様に、他のプロトコル,特に HTTP から WebSocket サーバに向けてデータが送信される際にも、接続の確立が失敗するように意図されている。 例えば,あり得そうなものとして、 HTML の “フォーム” が WebSocket サーバに submit された場合など。 これは主に、サーバに対し,ハンドシェイクを読み取った事実の立証を要求することにより、達成される。 すなわち,サーバからのハンドシェイクは、 WebSocket クライアントによってのみ送信され得る適切な要素†を含んでいる場合にのみ可能になるようにされている。 特に,この仕様が書かれた時点においては、攻撃者は, HTML と XMLHttpRequest [XMLHttpRequest] などの JavaScript API のみを利用するウェブ­ブラウザからは, Sec- で始まるヘッダを設定し得ない。 It is similarly intended to fail to establish a connection when data from other protocols, especially HTTP, is sent to a WebSocket server, for example, as might happen if an HTML "form" were submitted to a WebSocket server. This is primarily achieved by requiring that the server prove that it read the handshake, which it can only do if the handshake contains the appropriate parts, which can only be sent by a WebSocket client. In particular, at the time of writing of this specification, fields starting with |Sec-| cannot be set by an attacker from a web browser using only HTML and JavaScript APIs such as XMLHttpRequest [XMLHttpRequest].

【† 要素 — おそらく、プロトコル要素( RFC6365, 6 節 )を指す。 他所の一部の “要素” も同様。 】

1.7. TCP および HTTP との関係

この節は参考である。 _This section is non-normative._

WebSocket Protocol は、 TCP に基づく,独立のプロトコルである。 その HTTP との関係は、そのハンドシェイクが HTTP サーバからは Upgrade リクエストとして解釈される点のみに限られている。 The WebSocket Protocol is an independent TCP-based protocol. Its only relationship to HTTP is that its handshake is interpreted by HTTP servers as an Upgrade request.

WebSocket Protocol の既定においては、通常の WebSocket 接続にはポート 80 が利用され, TLS ( Transport Layer Security ) [RFC2818] を通してトンネルされた WebSocket 接続にはポート 443 が利用される。 By default, the WebSocket Protocol uses port 80 for regular WebSocket connections and port 443 for WebSocket connections tunneled over Transport Layer Security (TLS) [RFC2818].

1.8. 接続の確立

この節は参考である。 _This section is non-normative._

HTTP サーバと共有されているポートに接続が設けられる際は(ポート 80 と 443 へのトラフィックではごく普通に生じ得る状況)、その接続は, HTTP サーバからは Upgrade offer を伴う通常の GET リクエストに見えることになる。 IP アドレスが1個だけで, すべてのトラフィックが単独のホスト名の単独のサーバと行き交うような,比較的単純な配置においては、これは,配備されることになる WebSocket Protocol に基づくシステムにとり, 実用的なやり方になり得る。 より精巧な(例えば,負荷分散装置や複数のサーバを伴う)配置においては、 HTTP サーバから分離された, WebSocket 接続のための専用のホストの組み合わせの方が、おそらく管理し易いものになる。 この仕様が書かれた時点では、ポート 80 上と 443 上では接続の成功率が大きく異なっていて,ポート 443 の方がずっと高いことは記しておくべきだが、これは,時の経過に伴い変わり得るものでもある。 When a connection is to be made to a port that is shared by an HTTP server (a situation that is quite likely to occur with traffic to ports 80 and 443), the connection will appear to the HTTP server to be a regular GET request with an Upgrade offer. In relatively simple setups with just one IP address and a single server for all traffic to a single hostname, this might allow a practical way for systems based on the WebSocket Protocol to be deployed. In more elaborate setups (e.g., with load balancers and multiple servers), a dedicated set of hosts for WebSocket connections separate from the HTTP servers is probably easier to manage. At the time of writing of this specification, it should be noted that connections on ports 80 and 443 have significantly different success rates, with connections on port 443 being significantly more likely to succeed, though this may change with time.

1.9. WebSocket プロトコルを利用する下位プロトコル

この節は参考である。 _This section is non-normative._

クライアントは、ハンドシェイクの中に Sec-WebSocket-Protocol ヘッダを内包することにより,サーバに対し, 特定の下位プロトコルの利用をリクエストできる。 指定された場合,接続が確立されるためには、サーバは,その応答において,同じ名前のヘッダに, クライアントが選択した下位プロトコル値のいずれか一つを内包する必要がある。 The client can request that the server use a specific subprotocol by including the |Sec-WebSocket-Protocol| field in its handshake. If it is specified, the server needs to include the same field and one of the selected subprotocol values in its response for the connection to be established.

これらの下位プロトコル名は、 11.5 節 に従って登録されるべきである。 衝突の可能性を回避するため、下位プロトコルの考案者のドメイン名の ASCII バージョンを含む名前の利用が推奨される。 例えば、ある団体が Web に散在する多数のサーバへの実装が予期される Chat 下位プロトコルを作成して,それが "chat.example.com" と命名されたとして、別の組織が,競合する下位プロトコルを "chat.example.org" と命名していた場合、その2つの下位プロトコルは、サーバにおいて利用する下位プロトコルを,クライアントから送信される値に基づいて 動的に選択する形をとることにより、同時に実装され得るものになる。 These subprotocol names should be registered as per Section 11.5. To avoid potential collisions, it is recommended to use names that contain the ASCII version of the domain name of the subprotocol's originator. For example, if Example Corporation were to create a Chat subprotocol to be implemented by many servers around the Web, they could name it "chat.example.com". If the Example Organization called their competing subprotocol "chat.example.org", then the two subprotocols could be implemented by servers simultaneously, with the server dynamically selecting which subprotocol to use based on the value sent by the client.

下位プロトコルは、その名前を変更することにより,後方互換性を保たない形でバージョン付けできる。 例えば "bookings.example.net" から "v2.bookings.example.net" へ,等々。 これらの下位プロトコルは完全に別々の WebSocket クライアントと見なされることになる。 後方互換性を保つバージョン付けは、同じ下位プロトコル文字列を再利用して,この種の拡張性をサポートするように, 実際の下位プロトコルを注意深く設計することにより、実装できる。 Subprotocols can be versioned in backward-incompatible ways by changing the subprotocol name, e.g., going from "bookings.example.net" to "v2.bookings.example.net". These subprotocols would be considered completely separate by WebSocket clients. Backward-compatible versioning can be implemented by reusing the same subprotocol string but carefully designing the actual subprotocol to support this kind of extensibility.

2. 適合性の要件

“参考” と明示的に記された節に加えて,この仕様­内のすべての 図式, 例, 注記 は規定ではない。 他のすべては規定である。 All diagrams, examples, and notes in this specification are non-normative, as are all sections explicitly marked non-normative. Everything else in this specification is normative.

この文書におけるキーワード: 「〜しなければ(〜しては)ならない」 = “MUST (NOT)”, 「要求される」= REQUIRED, 「〜するべきである(でない)」 = “SHOULD (NOT)”, 「推奨される」 = “RECOMMENDED”, 「〜してもよい」 = “MAY”, 「任意選択」 = “OPTIONAL”, は、 [RFC2119] に則って解釈されるものとする。 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].

アルゴリズムの中の命令的言い回しによる要件(例えば “先頭部のスペース文字並びを取り除く” , “ false を返してこの手続きを中止する” など)は、アルゴリズムを引用する際に利用されているキーワード(「〜しなければならない」, 「〜するべき」, 「〜してもよい」, 等々)の意味の下に解釈されることになる。 Requirements phrased in the imperative as part of algorithms (such as "strip any leading space characters" or "return false and abort these steps") are to be interpreted with the meaning of the key word ("MUST", "SHOULD", "MAY", etc.) used in introducing the algorithm.

アルゴリズムまたは特定の手続きとして記される適合性の要件は、最終的な結果が等価になるのであれば,どのように実装されてもよい。 (特に、この仕様で定義されるアルゴリズムは追い易くなるように記述されており,パフォーマンスは考慮されていない。) Conformance requirements phrased as algorithms or specific steps MAY be implemented in any manner, so long as the end result is equivalent. (In particular, the algorithms defined in this specification are intended to be easy to follow and not intended to be performant.)

2.1. 各種用語とその他の表記規約

ASCII[ANSI.X3-4.1986] で定義される文字符号化スキームとする。 _ASCII_ shall mean the character-encoding scheme defined in [ANSI.X3-4.1986].

この文書は、STD 63 [RFC3629] で定義される, UTF-8 値と UTF-8 表記­形式を参照する。 This document makes reference to UTF-8 values and uses UTF-8 notational formats as defined in STD 63 [RFC3629].

次のスタイルが用いられる: 【 原文は素のテキストなので、 “文字によるマークアップ” が施されている。 】

  • 名前の付いたアルゴリズムや定義のような主要な語句は、 語句(定義), または 語句(リンク) のように示される。 Key terms such as named algorithms or definitions are indicated like _this_.
  • ヘッダ名は、 Sample-Header-Field のように示される。 【 この訳の中の語 “ヘッダ” は、ほぼすべて, “header field” の略記である(原文の “header field” の略語 “field” の対訳も “ヘッダ” に統一している)。 】 Names of header fields or variables are indicated like |this|.
  • 変数(または その値)は、 variable のように示される。 Variable values are indicated like /this/.

この文書は、 WebSocket 接続を失敗させる 手続きを参照する。 その手続きは 7.1.7 節 にて定義される。 This document references the procedure to _Fail the WebSocket Connection_. This procedure is defined in Section 7.1.7.

文字列の ASCII 小文字化 とは、 U+0041 〜 U+005A ( LATIN CAPITAL LETTER A 〜 LATIN CAPITAL LETTER Z )の範囲のすべての文字を対応する U+0061 〜 U+007A ( LATIN SMALL LETTER A 〜 LATIN SMALL LETTER Z )の範囲の文字に置換することを意味する。 _Converting a string to ASCII lowercase_ means replacing all characters in the range U+0041 to U+005A (i.e., LATIN CAPITAL LETTER A to LATIN CAPITAL LETTER Z) with the corresponding characters in the range U+0061 to U+007A (i.e., LATIN SMALL LETTER A to LATIN SMALL LETTER Z).

2つの文字列の ASCII 文字大小無視による比較 とは、 U+0041 〜 U+005A (すなわち LATIN CAPITAL LETTER A 〜 LATIN CAPITAL LETTER Z )の範囲の文字と対応する U+0061 〜 U+007A (すなわち LATIN SMALL LETTER A 〜 LATIN SMALL LETTER Z )の範囲の文字は同一視することを除き,それぞれの文字の符号位置ごとに厳密な比較を行うことを意味する。 Comparing two strings in an _ASCII case-insensitive_ manner means comparing them exactly, code point for code point, except that the characters in the range U+0041 to U+005A (i.e., LATIN CAPITAL LETTER A to LATIN CAPITAL LETTER Z) and the corresponding characters in the range U+0061 to U+007A (i.e., LATIN SMALL LETTER A to LATIN SMALL LETTER Z) are considered to also match.

この文書の用語 "URI" は [RFC3986] にて定義される。 The term "URI" is used in this document as defined in [RFC3986].

実装が WebSocket Protocol の一部として,データを 送信する 必要が生じた際は、実際の伝送を任意に遅延させてもよい。 例えば,より少数の IP パケットで送信するために データをバッファするなど。 When an implementation is required to _send_ data as part of the WebSocket Protocol, the implementation MAY delay the actual transmission arbitrarily, e.g., buffering data so as to send fewer IP packets.

この文書は、節に応じて, [RFC5234][RFC2616] の ABNF 変種のいずれも利用することに注意。 Note that this document uses both [RFC5234] and [RFC2616] variants of ABNF in different sections.

3. WebSocket URI

この仕様は、 [RFC5234] にて定義される ABNF 構文,および URI 仕様 [RFC3986] にて定義される用語と ABNF 生成規則を用いて,2つの URI スキームを定義する。 This specification defines two URI schemes, using the ABNF syntax defined in RFC 5234 [RFC5234], and terminology and ABNF productions defined by the URI specification RFC 3986 [RFC3986].

ws-URI = "ws:" "//" host [ ":" port ] path [ "?" query ]
wss-URI = "wss:" "//" host [ ":" port ] path [ "?" query ]

host = <host, [RFC3986] 3.2.2 節の定義による>

port = <port, [RFC3986] 3.2.3 節の定義による>
path = <path-abempty, [RFC3986] 3.3 節の定義による>
query = <query, [RFC3986] 3.4 節の定義による>

port 成分は任意選択である。 "ws" に対する既定のポート番号は 80 であり, "wss" に対する既定のポート番号は 443 である。 The port component is OPTIONAL; the default for "ws" is port 80, while the default for "wss" is port 443.

URI は、スキーム成分が "wss" に文字大小無視で合致するとき, “セキュア” と呼ばれる( “セキュア­フラグがセットされた” と呼ばれる)。 The URI is called "secure" (and it is said that "the secure flag is set") if the scheme component matches "wss" case-insensitively.

“リソース名” ( 4.1 節resource name )は、次を連結したものから構築できる: The "resource-name" (also known as /resource name/ in Section 4.1) can be constructed by concatenating the following:

WebSocket URI の文脈においては、素片­識別子は無意味であり,これらの URI に利用されてはならない。 他の URI スキーム同様、素片の開始を指示しない文字 "#" は %23 にエスケープされなければならない Fragment identifiers are meaningless in the context of WebSocket URIs and MUST NOT be used on these URIs. As with any URI scheme, the character "#", when not indicating the start of a fragment, MUST be escaped as %23.

4. opening ハンドシェイク

4.1. クライアントに課される要件

WebSocket 接続を確立する ためには、この節で定義されるように,クライアントは、接続を open してハンドシェイクを送信する。 接続は、初期­時には CONNECTING 状態 にあるものと定義される。 クライアントは、接続を open するにあたって,次のものを入力に供する必要がある:

  • 3 節 にて述べた, WebSocket URI の成分 host, port, resource name, および secure フラグ
  • 利用する 下位プロトコルのリスト protocols, および 拡張のリスト extensions
  • origin (クライアントがウェブ­ブラウザの場合)。
To _Establish a WebSocket Connection_, a client opens a connection and sends a handshake as defined in this section. A connection is defined to initially be in a CONNECTING state. A client will need to supply a /host/, /port/, /resource name/, and a /secure/ flag, which are the components of a WebSocket URI as discussed in Section 3, along with a list of /protocols/ and /extensions/ to be used. Additionally, if the client is a web browser, it supplies /origin/.

制御環境下で稼働しているクライアント,例えば,特定のキャリアに拘束された携帯電話機上のブラウザでは、接続の管理をネットワーク上の他のエージェントに負荷委譲してもよい。 その種の状況におけるクライアントは、この仕様の目的においては,その携帯機ソフトウェアとその種の任意のエージェントの両方を内包するものと見なされる。 Clients running in controlled environments, e.g., browsers on mobile handsets tied to specific carriers, MAY offload the management of the connection to another agent on the network. In such a situation, the client for the purposes of this specification is considered to include both the handset software and any such agents.

クライアントは、上述の入力の下に, WebSocket 接続を確立する ときは、接続を open し, opening ハンドシェイクを送信し, サーバからのハンドシェイク応答を読み取らなければならない。 接続がどのように open されるべきで, opening ハンドシェイクにおいて何が送信されるべきで, サーバからの応答がどのように解釈されるべきか,についての正確な要件は、この節の以下の部分で述べる。 以下のテキストにおける, "host" や "secure フラグ" などの 3 節 の語は、その節の定義に従うものとして用いられる。 When the client is to _Establish a WebSocket Connection_ given a set of (/host/, /port/, /resource name/, and /secure/ flag), along with a list of /protocols/ and /extensions/ to be used, and an /origin/ in the case of web browsers, it MUST open a connection, send an opening handshake, and read the server's handshake in response. The exact requirements of how the connection should be opened, what should be sent in the opening handshake, and how the server's response should be interpreted are as follows in this section. In the following text, we will use terms from Section 3, such as "/host/" and "/secure/ flag" as defined in that section.

  1. このアルゴリズムに渡される WebSocket URI の成分 ( host, port, resource-name, secure フラグ ) は、 3 節 にて指定される WebSocket URI の仕様に従って妥当でなければならない。 成分のどれか一つでも妥当でない場合、クライアントは, WebSocket 接続を失敗させて, この手続きを中止しなければならない正誤表による追記あり( Held for Document Update )。 secure フラグが false の場合の Mixed Content に関する取り扱いについて述べている。 】 The components of the WebSocket URI passed into this algorithm (/host/, /port/, /resource name/, and /secure/ flag) MUST be valid according to the specification of WebSocket URIs specified in Section 3. If any of the components are invalid, the client MUST _Fail the WebSocket Connection_ and abort these steps.
  2. ホスト host とポート port の組で識別されるリモート­ホスト( IP アドレス) 同じ[ IP アドレスとポートの組] への WebSocket 接続がすでにある場合、 クライアントは、そのリモート­ホストが別の名前として既知であるとしても,その接続が確立されるか, または その接続が失敗するまで,待機しなければならないどの一つの[ IP アドレスとポートの組]に対してもCONNECTING 状態 にある接続が同時に複数存在してはならない。 同じ IP アドレスとポートの組に対し,複数の接続が同時に試みられている場合、クライアントは、以下の手続きを実行している間,複数の接続が存在しないように, それらを直列化しなければならない正誤表による修正( Verified )】 If the client already has a WebSocket connection to the remote host (IP address) identified by /host/ and port /port/ pair same IP address and port pair, even if the remote host is known by another name, the client MUST wait until that connection has been established or for that connection to have failed. There MUST be no more than one connection in a CONNECTING state the CONNECTING state for any IP address and port pair. If multiple connections to the same IP address and port pair are attempted simultaneously, the client MUST serialize them so that there is no more than one connection at a time running through the following steps.

    クライアントがリモート­ホストの IP アドレスを決定できない場合(例えば,すべての通信が DNS クエリ自体を行うプロキシ­サーバを通して行われるために)、クライアントは,この段の目的においては 各ホスト名が別個のリモート­ホストを参照しているものと見なさなければならず,代わりに 同時の接続待ちの総数を適度に低い数に制限するべきである(例えば,クライアントが a.example.comb.example.com への同時の接続待ちを許容し得るとしても,単独のホストに対し 30 個の同時­接続がリクエストされた場合、許容されなくなり得る)。 例えば,ウェブ­ブラウザ文脈の下では、クライアントは、同時の接続待ち数を制限するにあたり,利用者が開いているタブウィンドウ数を考慮に入れる必要がある。 If the client cannot determine the IP address of the remote host (for example, because all communication is being done through a proxy server that performs DNS queries itself), then the client MUST assume for the purposes of this step that each host name refers to a distinct remote host, and instead the client SHOULD limit the total number of simultaneous pending connections to a reasonably low number (e.g., the client might allow simultaneous pending connections to a.example.com and b.example.com, but if thirty simultaneous connections to a single host are requested, that may not be allowed). For example, in a web browser context, the client needs to consider the number of tabs the user has open in setting a limit to the number of simultaneous pending connections.

    注記: これにより、単にリモート­ホストへ向けて多数の WebSocket 接続を open するような,スクリプトによる DoS 攻撃( denial-of-service attack )は、より困難になる。 更に、サーバは,攻撃された際には、接続の closing 前に一時停止して, クライアントによる再接続の頻度を抑制することにより,自身の負荷を軽減できる。 NOTE: This makes it harder for a script to perform a denial-of-service attack by just opening a large number of WebSocket connections to a remote host. A server can further reduce the load on itself when attacked by pausing before closing the connection, as that will reduce the rate at which the client reconnects.

    注記: クライアントが単独のリモート­ホスト向けて確立できる WebSocket 接続の総数に,制限はない。 サーバは、すでに接続­数が過度にあるホスト/IP アドレスからの接続の受理を拒んだり,あるいは 高­負荷を被った際には, リソースを浪費している接続を切断できる。 NOTE: There is no limit to the number of established WebSocket connections a client can have with a single remote host. Servers can refuse to accept connections from hosts/IP addresses with an excessive number of existing connections or disconnect resource-hogging connections when suffering high load.

  3. プロキシの用法: クライアントは、[ WebSocket Protocol を利用して ホスト host, ポート port に接続する際に,プロキシを利用するように設定されている ]場合には、そのプロキシに接続して, ホスト host, ポート port に向けて, TCP 接続を open する旨を求めるべきである。 _Proxy Usage_: If the client is configured to use a proxy when using the WebSocket Protocol to connect to host /host/ and port /port/, then the client SHOULD connect to that proxy and ask it to open a TCP connection to the host given by /host/ and the port given by /port/.

    例: 例えば,クライアントが、すべてのトラフィックに HTTP プロキシを利用していて,サーバ example.com のポート 80 への接続を試行している場合、次の行をプロキシ­サーバに送信することになるだろう: EXAMPLE: For example, if the client uses an HTTP proxy for all traffic, then if it was to try to connect to port 80 on server example.com, it might send the following lines to the proxy server:

    CONNECT example.com:80 HTTP/1.1
    Host: example.com
    

    パスワードがある場合の接続は次のようになるだろう: If there was a password, the connection might look like:

    CONNECT example.com:80 HTTP/1.1
    Host: example.com
    Proxy-authorization: Basic ZWRuYW1vZGU6bm9jYXBlcyE=
    

    クライアントがプロキシを利用するように設定されていない場合、 ホスト host, ポート port に向けて,直接の TCP 接続が open されるべきである。 If the client is not configured to use a proxy, then a direct TCP connection SHOULD be opened to the host given by /host/ and the port given by /port/.

    注記: WebSocket 接続のためのプロキシを他のプロキシとは別に選択するための,明示的な UI を供さない実装は、可用であれば, SOCKS5 [RFC1928] プロキシを WebSocket 接続に利用することが奨励される。 それができない場合、 HTTP 接続­用に設定されたプロキシを通して, HTTPS 接続­用に設定されたプロキシを利用することが望ましい。 NOTE: Implementations that do not expose explicit UI for selecting a proxy for WebSocket connections separate from other proxies are encouraged to use a SOCKS5 [RFC1928] proxy for WebSocket connections, if available, or failing that, to prefer the proxy configured for HTTPS connections over the proxy configured for HTTP connections.

    プロキシ自動設定スクリプトのために渡される URI は、 3 節 の WebSocket URI の定義に従って, host, port, resource-name, secure フラグ から構築されていなければならない For the purpose of proxy autoconfiguration scripts, the URI to pass the function MUST be constructed from /host/, /port/, /resource name/, and the /secure/ flag using the definition of a WebSocket URI as given in Section 3.

    注記: プロキシ自動設定スクリプトにおいては、 WebSocket Protocol であるかどうかは,スキームから判別できる(暗号化されていない接続に対しては "ws", 暗号化された接続に対しては "wss" ) NOTE: The WebSocket Protocol can be identified in proxy autoconfiguration scripts from the scheme ("ws" for unencrypted connections and "wss" for encrypted connections).

  4. 直接­接続が失敗した, あるいは利用しているプロキシがエラーを返したなどの理由で,接続を open できなかった場合、クライアントは, WebSocket 接続を失敗させて, 接続の試みを中止しなければならない If the connection could not be opened, either because a direct connection failed or because any proxy used returned an error, then the client MUST _Fail the WebSocket Connection_ and abort the connection attempt.
  5. secure が true の場合、クライアントは、接続を open した後, ハンドシェイク­データ [RFC2818] を送信する前までに,接続を通して TLS ハンドシェイクを行わなければならない。 これが失敗した場合(例えば,サーバの証明書を検証できなかったとき)、クライアントは、 WebSocket 接続を失敗させて, 接続を中止しなければならない。 他の場合、このチャンネル上の以降の通信はすべて,暗号化されたトンネル [RFC5246] を通して実行されなければならない If /secure/ is true, the client MUST perform a TLS handshake over the connection after opening the connection and before sending the handshake data [RFC2818]. If this fails (e.g., the server's certificate could not be verified), then the client MUST _Fail the WebSocket Connection_ and abort the connection. Otherwise, all further communication on this channel MUST run through the encrypted tunnel [RFC5246].

    クライアントは、 TLS ハンドシェイクの Server Name Indication 拡張 [RFC6066] を利用しなければならない Clients MUST use the Server Name Indication extension in the TLS handshake [RFC6066].

サーバへの接続がいったん確立されたなら(プロキシ経由の, または TLS 暗号化トンネルを通した接続も含め)、クライアントは,サーバへ向けて opening ハンドシェイクを送信しなければならない。 ハンドシェイクは、必須の, およびオプションのヘッダのリストを伴う, HTTP Upgrade リクエストからなる。 このハンドシェイクには次に挙げる要件が課される。 Once a connection to the server has been established (including a connection via a proxy or over a TLS-encrypted tunnel), the client MUST send an opening handshake to the server. The handshake consists of an HTTP Upgrade request, along with a list of required and optional header fields. The requirements for this handshake are as follows.

  1. ハンドシェイクは [RFC2616] の指定に従って 妥当な HTTP リクエストでなければならない The handshake MUST be a valid HTTP request as specified by [RFC2616].
  2. リクエストのメソッドは GET であって, かつ HTTP バージョンは 1.1 以上 でなければならない The method of the request MUST be GET, and the HTTP version MUST be at least 1.1.

    例えば, WebSocket URI が "ws://example.com/chat" ならば、送信される最初の行は "GET /chat HTTP/1.1" になっているべきである。 For example, if the WebSocket URI is "ws://example.com/chat", the first line sent should be "GET /chat HTTP/1.1".

  3. リクエストの "Request-URI" の部分は、3 節 で定義される resource-name (相対 URI )に合致するか,または 構文解析された際に対応する ws/wss URI に合致する resource-name, host, port を持つような 絶対 http/https URI に合致しなければならない The "Request-URI" part of the request MUST match the /resource name/ defined in Section 3 (a relative URI) or be an absolute http/https URI that, when parsed, has a /resource name/, /host/, and /port/ that match the corresponding ws/wss URI.
  4. リクエストは、[ オプションで(あるいは,既定のポートを利用しない場合は)[ ":", port ]が後続する, host ]を値にとる Host ヘッダを含んでいなければならない The request MUST contain a |Host| header field whose value contains /host/ plus optionally ":" followed by /port/ (when not using the default port).
  5. リクエストは Upgrade ヘッダを含んでいて, かつ その値はキーワード "websocket" を内包していなければならない The request MUST contain an |Upgrade| header field whose value MUST include the "websocket" keyword.
  6. リクエストは Connection ヘッダを含んでいて, かつ その値は "Upgrade" トークンを内包していなければならない The request MUST contain a |Connection| header field whose value MUST include the "Upgrade" token.
  7. リクエストは Sec-WebSocket-Key ヘッダを内包していて, かつ その値は、無作為に選ばれた 16 バイト値を base64 符号化した nonce でなければならない[RFC4648] 4 節 を見よ)。 nonce は、それぞれの接続ごとに,無作為に選ばれなければならない【 nonce :一度限りのもの( “number used once” )】 The request MUST include a header field with the name |Sec-WebSocket-Key|. The value of this header field MUST be a nonce consisting of a randomly selected 16-byte value that has been base64-encoded (see Section 4 of [RFC4648]). The nonce MUST be selected randomly for each connection.

    注記: 例えば,無作為に選ばれた値がバイトの並び 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 であった場合、ヘッダの値は "AQIDBAUGBwgJCgsMDQ4PEC==" "AQIDBAUGBwgJCgsMDQ4PEA==" になる。 正誤表による修正( Verified )】 NOTE: As an example, if the randomly selected value was the sequence of bytes 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10, the value of the header field would be "AQIDBAUGBwgJCgsMDQ4PEC=="

  8. ブラウザ クライアントからのリクエストは、 Origin ヘッダ [RFC6454] を内包しなければならない。 接続が非ブラウザ クライアントからのものである場合、リクエストは,そのクライアントの意味論がブラウザ クライアントに対してここに述べられるユースケースに合致するならば、このヘッダを内包してもよい。 このヘッダの値は、接続を確立­中のコードが属する実行文脈の生成元を ASCII に直列化したものである。 このヘッダの値がどのように構築されるかについての詳細は、 [RFC6454] を見よ。 The request MUST include a header field with the name |Origin| [RFC6454] if the request is coming from a browser client. If the connection is from a non-browser client, the request MAY include this header field if the semantics of that client match the use-case described here for browser clients. The value of this header field is the ASCII serialization of origin of the context in which the code establishing the connection is running. See [RFC6454] for the details of how this header field value is constructed.

    例として, www.example.com からダウンロードされたコードが ww2.example.com へ向けて接続の確立を試みる場合、ヘッダの値は "http://www.example.com" になるであろう。 As an example, if code downloaded from www.example.com attempts to establish a connection to ww2.example.com, the value of the header field would be "http://www.example.com".

  9. リクエストは Sec-WebSocket-Version ヘッダを内包していて, かつ その値は 13 でなければならない The request MUST include a header field with the name |Sec-WebSocket-Version|. The value of this header field MUST be 13.

    注記: この文書の草案のバージョン番号( -09, -10, -11, -12 )が公示されたが(それらのほとんどは、伝送路プロトコルに対する変更ではなく,編集上の変更や明確化からなる)、番号 9, 10, 11, 12 は Sec-WebSocket-Version の妥当な番号としては利用されていない。 これらの値は IANA レジストリに予約済みであるが、これまでも利用されておらず,今後も利用されることはない。 NOTE: Although draft versions of this document (-09, -10, -11, and -12) were posted (they were mostly comprised of editorial changes and clarifications and not changes to the wire protocol), values 9, 10, 11, and 12 were not used as valid values for Sec-WebSocket-Version. These values were reserved in the IANA registry but were not and will not be used.

  10. リクエストは Sec-WebSocket-Protocol ヘッダを内包してもよい。 もし在れば,この値は、クライアントが希望する順序にカンマ区切りで並べられた,1個以上の下位プロトコルを指示する。 この値を構成する各­要素は、 [RFC2616] の定義に従って, U+0021 〜 U+007E の範囲の文字からなる,区切り文字を含まず, 空でない,文字列でなければならず、それぞれが一意的でなければならない。 このヘッダ値に対する ABNF は 1#token であり,その構成子と規則の定義は [RFC2616] にて与えられる。 The request MAY include a header field with the name |Sec-WebSocket-Protocol|. If present, this value indicates one or more comma-separated subprotocol the client wishes to speak, ordered by preference. The elements that comprise this value MUST be non-empty strings with characters in the range U+0021 to U+007E not including separator characters as defined in [RFC2616] and MUST all be unique strings. The ABNF for the value of this header field is 1#token, where the definitions of constructs and rules are as given in [RFC2616].

  11. リクエストは Sec-WebSocket-Extensions ヘッダを内包してもよい。 もし在れば,この値は、クライアントが希望する,1個以上のプロトコル­レベルの拡張を指示する。 このヘッダの解釈と形式は 9.1 節 にて述べる。 The request MAY include a header field with the name |Sec-WebSocket-Extensions|. If present, this value indicates the protocol-level extension(s) the client wishes to speak. The interpretation and format of this header field is described in Section 9.1.
  12. リクエストは、例えばクッキー [RFC6265]Authorization ヘッダ[RFC2616] のような認証に関係するヘッダなど,他の任意のヘッダを内包してもよい。 それらは、それらを定義する文書に従って処理される。 The request MAY include any other header fields, for example, cookies [RFC6265] and/or authentication-related header fields such as the |Authorization| header field [RFC2616], which are processed according to documents that define them.

クライアントは、 opening ハンドシェイクを送信したなら、更にデータを送信する前に,サーバからの応答を待機しなければならない。 クライアントは、以下のようにサーバ応答の妥当­性を検証しなければならない Once the client's opening handshake has been sent, the client MUST wait for a response from the server before sending any further data. The client MUST validate the server's response as follows:

  1. サーバから受信されたステータスコードが 101 でない場合、クライアントは応答を HTTP [RFC2616] の手続きに従って取り扱う。 特に,クライアントは、 401 ステータスコードを受信した際には,認証を行い得る。 サーバは、 3xx ステータスコードを用いてクライアントをリダイレクトし得る(ただし,クライアントがそれに追随することは要求されていない),等々。 他の場合、次へ進む。 If the status code received from the server is not 101, the client handles the response per HTTP [RFC2616] procedures. In particular, the client might perform authentication if it receives a 401 status code; the server might redirect the client using a 3xx status code (but clients are not required to follow them), etc. Otherwise, proceed as follows.
  2. 応答が次に該当する場合、クライアントは WebSocket 接続を失敗させ なければならない

    • 応答は Upgrade ヘッダを欠いている場合、あるいは Upgrade ヘッダ値は "websocket" に ASCII 文字大小無視で合致しない値を含んでいる場合。 If the response lacks an |Upgrade| header field or the |Upgrade| header field contains a value that is not an ASCII case-insensitive match for the value "websocket", the client MUST _Fail the WebSocket Connection_.
    • 応答は Connection ヘッダを欠いている場合、あるいは Connection ヘッダ値は "Upgrade" に ASCII 文字大小無視で合致するトークンを含んでいない場合。 If the response lacks a |Connection| header field or the |Connection| header field doesn't contain a token that is an ASCII case-insensitive match for the value "Upgrade", the client MUST _Fail the WebSocket Connection_.
    • 応答は Sec-WebSocket-Accept ヘッダを欠いている場合、あるいは Sec-WebSocket-Accept ヘッダ値は,頭部と尾部の空白を無視した上で,[ ( base64 復号されてない,文字列としての) Sec-WebSocket-Key の値と文字列 "258EAFA5-E914-47DA-95CA-C5AB0DC85B11" とを連結してから SHA-1 をとった結果を base64 符号化した値 ]でない場合。 If the response lacks a |Sec-WebSocket-Accept| header field or the |Sec-WebSocket-Accept| contains a value other than the base64-encoded SHA-1 of the concatenation of the |Sec-WebSocket-Key| (as a string, not base64-decoded) with the string "258EAFA5-E914-47DA-95CA-C5AB0DC85B11" but ignoring any leading and trailing whitespace, the client MUST _Fail the WebSocket Connection_.
    • 応答は Sec-WebSocket-Extensions ヘッダを内包していて, かつ そのヘッダ値は クライアントのハンドシェイクには無かった拡張の利用を指示している場合(サーバがクライアントからリクエストされなかった拡張を指示した)。 (どの拡張がリクエストされたかを決定するための,このヘッダの構文解析法については、 9.1 節 にて論じられる。) If the response includes a |Sec-WebSocket-Extensions| header field and this header field indicates the use of an extension that was not present in the client's handshake (the server has indicated an extension not requested by the client), the client MUST _Fail the WebSocket Connection_. (The parsing of this header field to determine which extensions are requested is discussed in Section 9.1.)
    • 応答は Sec-WebSocket-Protocol ヘッダを内包していて, かつ そのヘッダ値は クライアントのハンドシェイクには無かった下位プロトコルの利用を指示している場合(サーバがクライアントからリクエストされなかった下位プロトコルを指示した)。 If the response includes a |Sec-WebSocket-Protocol| header field and this header field indicates the use of a subprotocol that was not present in the client's handshake (the server has indicated a subprotocol not requested by the client), the client MUST _Fail the WebSocket Connection_.

サーバの応答が,この節と 4.2.2 節 に定義されているサーバのハンドシェイクに課される要件に適合していない場合、クライアントは WebSocket 接続を失敗させ なければならない If the server's response does not conform to the requirements for the server's handshake as defined in this section and in Section 4.2.2, the client MUST _Fail the WebSocket Connection_.

[RFC2616] に従い、 HTTP リクエストと HTTP 応答のいずれについても,すべてのヘッダ名における文字の大小は無視されることに注意。 Please note that according to [RFC2616], all header field names in both HTTP requests and HTTP responses are case-insensitive.

サーバ応答の妥当性が上で与えられたように検証されたとき、 WebSocket 接続が確立された と言い, WebSocket 接続は OPEN 状態 にあるとされる。 利用中の拡張 は、サーバのハンドシェイクに供された Sec-WebSocket-Extensions ヘッダの値に等しい値の(空にもなり得る)文字列であるか, または そのヘッダがサーバのハンドシェイクに無かった場合は null 値であるものと定義される。 利用中の下位プロトコル は、サーバのハンドシェイクに供された Sec-WebSocket-Protocol ヘッダの値であるか, または そのヘッダがサーバのハンドシェイクに無かった場合は null 値であるものと定義される。 加えて,サーバのハンドシェイクに( [RFC6265] の定義に従った)クッキーが設定されるべきであることを指示するヘッダがある場合、これらのクッキーを指して サーバの opening ハンドシェイクの間に設定されるクッキー と呼ぶ。 If the server's response is validated as provided for above, it is said that _The WebSocket Connection is Established_ and that the WebSocket Connection is in the OPEN state. The _Extensions In Use_ is defined to be a (possibly empty) string, the value of which is equal to the value of the |Sec-WebSocket-Extensions| header field supplied by the server's handshake or the null value if that header field was not present in the server's handshake. The _Subprotocol In Use_ is defined to be the value of the |Sec-WebSocket-Protocol| header field in the server's handshake or the null value if that header field was not present in the server's handshake. Additionally, if any header fields in the server's handshake indicate that cookies should be set (as defined by [RFC6265]), these cookies are referred to as _Cookies Set During the Server's Opening Handshake_.

4.2. サーバ側に課される要件

サーバは接続の管理をネットワーク上の他のエージェントに負荷委譲してもよい。 例えば負荷分散装置( load balancer )や逆プロキシ( reverse proxy )など。 その種の状況では、サーバは,この仕様の目的においては、サーバ側の通信基盤のすべての部分,最初の機器から TCP 接続の終了まで、リクエストの処理と応答の送信についてサーバ側に帰着されるすべてを内包するものと見なされる。 Servers MAY offload the management of the connection to other agents on the network, for example, load balancers and reverse proxies. In such a situation, the server for the purposes of this specification is considered to include all parts of the server-side infrastructure from the first device to terminate the TCP connection all the way to the server that processes requests and sends responses.

例: データセンターは、適切なハンドシェイクを伴う WebSocket リクエストに応答するサーバを持つことがあり,接続を,実際にデータ­フレームを処理する別サーバに 渡し得る。 この仕様の目的においては、 “サーバ” は,両者のコンピュータの組み合わせになる。 EXAMPLE: A data center might have a server that responds to WebSocket requests with an appropriate handshake and then passes the connection to another server to actually process the data frames. For the purposes of this specification, the "server" is the combination of both computers.

4.2.1. クライアントからの opening ハンドシェイクの読み取り

クライアントは、 WebSocket 接続を開始するとき,自身の分担の opening ハンドシェイクを送信する。 サーバは、サーバ側分担のハンドシェイクの生成に必要な情報を取得するために,少なくともこのハンドシェイクの一部分を構文解析しなければならない。 When a client starts a WebSocket connection, it sends its part of the opening handshake. The server must parse at least part of this handshake in order to obtain the necessary information to generate the server part of the handshake.

クライアントの opening ハンドシェイクは、以下に挙げる部分からなる。 サーバは、ハンドシェイクの読み取り中に,クライアントが下の記述に合致するハンドシェイクを送信していないことを検出した場合( [RFC2616] に従って,ヘッダの順序は重要でないことに注意) — ハンドシェイクの成分に指定されている ABNF 文法への違反も含め,それに限られず — クライアントからのハンドシェイクの処理を停止して,適切なエラーコードを伴う HTTP 応答( 400 Bad Request など)を返さなければならない The client's opening handshake consists of the following parts. If the server, while reading the handshake, finds that the client did not send a handshake that matches the description below (note that as per [RFC2616], the order of the header fields is not important), including but not limited to any violations of the ABNF grammar specified for the components of the handshake, the server MUST stop processing the client's handshake and return an HTTP response with an appropriate error code (such as 400 Bad Request).

  • 3 節 で定義される resource-name として解釈されるべきである "Request-URI" [RFC2616] または( resource-name を含んでいる絶対 HTTP/HTTPS URI )を内包している, HTTP/1.1 以上の GET リクエスト。 An HTTP/1.1 or higher GET request, including a "Request-URI" [RFC2616] that should be interpreted as a /resource name/ defined in Section 3 (or an absolute HTTP/HTTPS URI containing the /resource name/).
  • サーバの権限( authority )を含んでいる Host ヘッダ。 A |Host| header field containing the server's authority.
  • ASCII 文字大小無視の値として値 "websocket" を含んでいる, Upgrade ヘッダ。 An |Upgrade| header field containing the value "websocket", treated as an ASCII case-insensitive value.
  • ASCII 文字大小無視の値としてトークン "Upgrade" を内包する, Connection ヘッダ。 A |Connection| header field that includes the token "Upgrade", treated as an ASCII case-insensitive value.
  • base64 に符号化された値( [RFC4648] 4 節 参照)であって,復号されたときに長さ 16 バイトの値になる, Sec-WebSocket-Key ヘッダ。 A |Sec-WebSocket-Key| header field with a base64-encoded (see Section 4 of [RFC4648]) value that, when decoded, is 16 bytes in length.
  • 値 13 の Sec-WebSocket-Version ヘッダ。 A |Sec-WebSocket-Version| header field, with a value of 13.
  • オプションで、 Origin ヘッダ。 このヘッダは、すべてのブラウザ クライアントから送信される。 このヘッダを欠く接続の試みは、ブラウザ クライアントからのものと解釈されるべきでない。 Optionally, an |Origin| header field. This header field is sent by all browser clients. A connection attempt lacking this header field SHOULD NOT be interpreted as coming from a browser client.
  • オプションで、クライアントの希望順に並べられた,下位プロトコルを指示する値のリストを伴う, Sec-WebSocket-Protocol ヘッダ。 Optionally, a |Sec-WebSocket-Protocol| header field, with a list of values indicating which protocols the client would like to speak, ordered by preference.
  • オプションで、クライアントの希望順に並べられた,拡張を指示する値のリストを伴う, Sec-WebSocket-Extensions ヘッダ。 このヘッダの解釈については 9.1 節 にて論じられる。 Optionally, a |Sec-WebSocket-Extensions| header field, with a list of values indicating which extensions the client would like to speak. The interpretation of this header field is discussed in Section 9.1.
  • オプションで、サーバに向けて,クッキーを送信したり認証をリクエストする際に用いられる,他のヘッダ。 未知のヘッダは [RFC2616] に従って無視される。 Optionally, other header fields, such as those used to send cookies or request authentication to a server. Unknown header fields are ignored, as per [RFC2616].

4.2.2. サーバによる opening ハンドシェイクの送信

サーバは、クライアントがサーバへの WebSocket 接続を確立する際に,その接続を受理して, opening ハンドシェイクを送信するためには、次の手続きを完了しなければならない When a client establishes a WebSocket connection to a server, the server MUST complete the following steps to accept the connection and send the server's opening handshake.

  1. 接続が HTTPS ( HTTP-over-TLS )ポートに対して生じたものである場合、接続を通して TLS ハンドシェイクを行う。 これに失敗した場合(例えば,クライアントが extended client hello "server_name" においてサーバがホストしないホスト名を指示した場合)、接続を close する。 他の場合、接続における,それ以降の(サーバのハンドシェイクも含む)すべての通信は、暗号化されたトンネル [RFC5246] を通して実行されなければならない If the connection is happening on an HTTPS (HTTP-over-TLS) port, perform a TLS handshake over the connection. If this fails (e.g., the client indicated a host name in the extended client hello "server_name" extension that the server does not host), then close the connection; otherwise, all further communication for the connection (including the server's handshake) MUST run through the encrypted tunnel [RFC5246].
  2. サーバは、例えば [RFC2616] に述べられるように,対応する WWW-Authenticate ヘッダを伴う 401 ステータスコードを返すことにより,追加のクライアント認証を行うことができる。 The server can perform additional client authentication, for example, by returning a 401 status code with the corresponding |WWW-Authenticate| header field as described in [RFC2616].
  3. サーバは、 3xx ステータスコード [RFC2616] を用いて, クライアントをリダイレクトしてもよい。 この段は、上述の認証オプションの段と伴に,その前後いずれにも生じ得ることに注意。 The server MAY redirect the client using a 3xx status code [RFC2616]. Note that this step can happen together with, before, or after the optional authentication step described above.
  4. 次の情報を確定させる: Establish the following information:

    origin
    クライアントからのハンドシェイクの中の Origin ヘッダは、接続を確立­中のスクリプトの生成元を指示する。 生成元は ASCII に直列化され,小文字化される。 サーバは、この情報を着信­接続を受理するかどうかの判断材料にしてもよい。 サーバが生成元の妥当性を検証しない場合、どこからの接続も受理することになる。 この接続の受理を望まない場合、適切な HTTP エラーコード(例えば, 403 Forbidden )を返して,この節にて述べている WebSocket ハンドシェイクを中止しなければならない。 更なる詳細は 10 節 を参照。 The |Origin| header field in the client's handshake indicates the origin of the script establishing the connection. The origin is serialized to ASCII and converted to lowercase. The server MAY use this information as part of a determination of whether to accept the incoming connection. If the server does not validate the origin, it will accept connections from anywhere. If the server does not wish to accept this connection, it MUST return an appropriate HTTP error code (e.g., 403 Forbidden) and abort the WebSocket handshake described in this section. For more detail, refer to Section 10.
    key
    クライアントからのハンドシェイクの中の Sec-WebSocket-Key ヘッダは、復号された時の長さが 16 バイトになる, base64 符号化­値を内包する。 この値は、接続の受理を指示するために,サーバのハンドシェイクの作成に(符号化されたままの形で)利用される。 サーバは、 Sec-WebSocket-Key 値を base64 から復号する必要はない。 The |Sec-WebSocket-Key| header field in the client's handshake includes a base64-encoded value that, if decoded, is 16 bytes in length. This (encoded) value is used in the creation of the server's handshake to indicate an acceptance of the connection. It is not necessary for the server to base64-decode the |Sec-WebSocket-Key| value.
    version
    クライアントからのハンドシェイクの中の Sec-WebSocket-Version ヘッダは、クライアントが通信を試みている WebSocket Protocol のバージョンを内包する。 このバージョンがサーバが解せるバージョンに合致しない場合、サーバは、この節にて述べられる WebSocket ハンドシェイクを中止して, 適切な HTTP エラーコード( 426 Upgrade Required など),および サーバが解せる一つ以上のバージョンを指示する Sec-WebSocket-Version ヘッダを送信しなければならない The |Sec-WebSocket-Version| header field in the client's handshake includes the version of the WebSocket Protocol with which the client is attempting to communicate. If this version does not match a version understood by the server, the server MUST abort the WebSocket handshake described in this section and instead send an appropriate HTTP error code (such as 426 Upgrade Required) and a |Sec-WebSocket-Version| header field indicating the version(s) the server is capable of understanding.
    resource name
    サーバから提供されるサービスの識別子。 サーバが複数のサービスを提供する場合、値はクライアントからのハンドシェイクの中の, GET メソッドの "Request-URI" [RFC2616] の中に与えられたリソース名から導出されるべきである。 リクエストされたサービスが可用でない場合、サーバは、適切な HTTP エラーコード( 404 Not Found など)を送信して, WebSocket ハンドシェイクを中止しなければならない An identifier for the service provided by the server. If the server provides multiple services, then the value should be derived from the resource name given in the client's handshake in the "Request-URI" [RFC2616] of the GET method. If the requested service is not available, the server MUST send an appropriate HTTP error code (such as 404 Not Found) and abort the WebSocket handshake.
    subprotocol
    サーバにて利用できる下位プロトコルを表現する単独の値であるか, または null 。 選ばれる値は、クライアントからのハンドシェイクの中から,具体的には Sec-WebSocket-Protocol ヘッダの値の中からサーバがこの接続に用いることにする一つを(もしあれば)選択することにより、導出されなければならない。 クライアントからのハンドシェイクにそのようなヘッダが含まれていないか, または サーバがクライアントがリクエストした下位プロトコルのどれにも同意しない場合、受理­可能な値は null のみになる。 そのようなヘッダの不在は null 値と等価である(すなわち,サーバが提示されたどの下位プロトコルにも同意しない場合、その応答に Sec-WebSocket-Protocol ヘッダを返してはならない)。 この目的においては、空文字列は null 値と同じではなく,このヘッダに対する合法な値ではない。 このヘッダ値の ABNF は (token) であり,その構成子と規則の定義は [RFC2616] にて与えられる。 Either a single value representing the subprotocol the server is ready to use or null. The value chosen MUST be derived from the client's handshake, specifically by selecting one of the values from the |Sec-WebSocket-Protocol| field that the server is willing to use for this connection (if any). If the client's handshake did not contain such a header field or if the server does not agree to any of the client's requested subprotocols, the only acceptable value is null. The absence of such a field is equivalent to the null value (meaning that if the server does not wish to agree to one of the suggested subprotocols, it MUST NOT send back a |Sec-WebSocket-Protocol| header field in its response). The empty string is not the same as the null value for these purposes and is not a legal value for this field. The ABNF for the value of this header field is (token), where the definitions of constructs and rules are as given in [RFC2616].
    extensions
    サーバにて利用できるプロトコル­レベルの拡張を表現する,リスト(空にもなり得る)。 サーバが複数の拡張をサポートする場合、値はクライアントからのハンドシェイクの中から,具体的には Sec-WebSocket-Extensions ヘッダから1個以上の値を選択することにより,導出されなければならない。 そのようなヘッダの不在は null 値と等価である。 この目的においては、空文字列は null 値と同じではない。 クライアントからリストされなかった拡張がリストされてはならない。 これらの値の選択と解釈の仕方は 9.1 節 にて論じられる。 A (possibly empty) list representing the protocol-level extensions the server is ready to use. If the server supports multiple extensions, then the value MUST be derived from the client's handshake, specifically by selecting one or more of the values from the |Sec-WebSocket-Extensions| field. The absence of such a field is equivalent to the null value. The empty string is not the same as the null value for these purposes. Extensions not listed by the client MUST NOT be listed. The method by which these values should be selected and interpreted is discussed in Section 9.1.
  5. サーバは、着信­接続の受理を選ぶ場合、以下を指示する妥当な HTTP 応答で 返信しなければならない If the server chooses to accept the incoming connection, it MUST reply with a valid HTTP response indicating the following.

    1. [RFC2616] に従う, 101 応答コードを伴う Status-Line 。 その種の応答は、 "HTTP/1.1 101 Switching Protocols" のような形をとるであろう。 A Status-Line with a 101 response code as per RFC 2616 [RFC2616]. Such a response could look like "HTTP/1.1 101 Switching Protocols".
    2. [RFC2616] に従う,値 "websocket" にされた Upgrade ヘッダ。 An |Upgrade| header field with value "websocket" as per RFC 2616 [RFC2616].
    3. 値 "Upgrade" にされた Connection ヘッダ。 A |Connection| header field with value "Upgrade".
    4. Sec-WebSocket-Accept ヘッダ。 このヘッダの値は、上の 4.2.2 節 第 4 段で定義される key と文字列 "258EAFA5-E914-47DA-95CA-C5AB0DC85B11" を連結した値から SHA-1 ハッシュをとって得られる 20 バイト値を, base64 に符号化( [RFC4648] 4 節 )することにより、構築される。 A |Sec-WebSocket-Accept| header field. The value of this header field is constructed by concatenating /key/, defined above in step 4 in Section 4.2.2, with the string "258EAFA5-E914-47DA-95CA-C5AB0DC85B11", taking the SHA-1 hash of this concatenated value to obtain a 20-byte value and base64-encoding (see Section 4 of [RFC4648]) this 20-byte hash.

      このヘッダの ABNF [RFC2616] は次で定義される: The ABNF [RFC2616] of this header field is defined as follows:

      Sec-WebSocket-Accept   = base64-value-non-empty
      base64-value-non-empty = (1*base64-data [ base64-padding ]) |
                               base64-padding
      base64-data      = 4base64-character
      base64-padding   = (2base64-character "==") |
                         (3base64-character "=")
      base64-character = ALPHA | DIGIT | "+" | "/"
      

      注記: 例えば、クライアントからのハンドシェイクの Sec-WebSocket-Key ヘッダの値が "dGhlIHNhbXBsZSBub25jZQ==" であったなら、サーバは:

      1. まず、文字列 "258EAFA5-E914-47DA-95CA-C5AB0DC85B11" を付加して,文字列 "dGhlIHNhbXBsZSBub25jZQ==258EAFA5-E914-47DA-95CA-C5AB0DC85B11" を形成する。
      2. 次に、その SHA-1 ハッシュをとり,値[ 0xb3 0x7a 0x4f 0x2c 0xc0 0x62 0x4f 0x16 0x90 0xf6 0x46 0x06 0xcf 0x38 0x59 0x45 0xb2 0xbe 0xc4 0xea ]を得る。
      3. 最後に、この値を base64 符号化して得られる値 "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=" が, Sec-WebSocket-Accept ヘッダに返されることになる。

      NOTE: As an example, if the value of the |Sec-WebSocket-Key| header field in the client's handshake were "dGhlIHNhbXBsZSBub25jZQ==", the server would append the string "258EAFA5-E914-47DA-95CA-C5AB0DC85B11" to form the string "dGhlIHNhbXBsZSBub25jZQ==258EAFA5-E914-47DA-95CA-C5AB0DC85B11". The server would then take the SHA-1 hash of this string, giving the value 0xb3 0x7a 0x4f 0x2c 0xc0 0x62 0x4f 0x16 0x90 0xf6 0x46 0x06 0xcf 0x38 0x59 0x45 0xb2 0xbe 0xc4 0xea. This value is then base64-encoded, to give the value "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=", which would be returned in the |Sec-WebSocket-Accept| header field.

    5. オプションで、 4.2.2 節 の第 4 段で定義される subprotocol を値にとる, Sec-WebSocket-Protocol ヘッダ。 Optionally, a |Sec-WebSocket-Protocol| header field, with a value /subprotocol/ as defined in step 4 in Section 4.2.2.
    6. オプションで、 4.2.2 節 の第 4 段で定義される extensions を値にとる, Sec-WebSocket-Extensions ヘッダ。 複数の拡張を利用する場合、それらすべてを単独の Sec-WebSocket-Extensions ヘッダ内にリストするか, あるいは複数個の Sec-WebSocket-Extensions ヘッダに分割してあてがうこともできる。 Optionally, a |Sec-WebSocket-Extensions| header field, with a value /extensions/ as defined in step 4 in Section 4.2.2. If multiple extensions are to be used, they can all be listed in a single |Sec-WebSocket-Extensions| header field or split between multiple instances of the |Sec-WebSocket-Extensions| header field.

これにより、サーバのハンドシェイクは完了する。 サーバがこれらの手続きを WebSocket ハンドシェイクを中止せずに完遂した場合、サーバは WebSocket 接続が確立されたものと見なし, WebSocket 接続は OPEN 状態 になる。 この時点から,サーバはデータの送信(および受信)を始めてよい。 This completes the server's handshake. If the server finishes these steps without aborting the WebSocket handshake, the server considers the WebSocket connection to be established and that the WebSocket connection is in the OPEN state. At this point, the server may begin sending (and receiving) data.

4.3. ハンドシェイクに用いられる新たなヘッダの ABNF 総覧

この節では、 [RFC2616] 2.1 節 による, “暗黙の *LWS 規則” も内包する, ABNF 構文/規則が利用される。 【 *LWS :省略可能( “*” )な連続空白( Linear White Space, “線形空白”)】 This section is using ABNF syntax/rules from Section 2.1 of [RFC2616], including the "implied *LWS rule".

この節では, ABNF において次の規約が用いられることに注意: ABNF 規則の名前うち,一部のものは、対応するヘッダ名に対応する。 その種の規則は、対応するヘッダの値を表記する。 例えば, Sec-WebSocket-Key ABNF 規則は、 Sec-WebSocket-Key ヘッダの値の構文を記述する。 名前の中に "-Client" 接尾辞を伴う ABNF 規則は、クライアントからサーバへ向けて送信されるリクエストにおいてのみ用いられる。 名前の中に "-Server" 接尾辞を伴う ABNF 規則は、サーバからクライアントへ向けて送信される応答においてのみ用いられる。 例えば, ABNF 規則 Sec-WebSocket-Protocol-Client は、クライアントからサーバに向けて送信される, Sec-WebSocket-Protocol ヘッダ値の構文を記述する。 Note that the following ABNF conventions are used in this section. Some names of the rules correspond to names of the corresponding header fields. Such rules express values of the corresponding header fields, for example, the Sec-WebSocket-Key ABNF rule describes syntax of the |Sec-WebSocket-Key| header field value. ABNF rules with the "-Client" suffix in the name are only used in requests sent by the client to the server; ABNF rules with the "-Server" suffix in the name are only used in responses sent by the server to the client. For example, the ABNF rule Sec-WebSocket-Protocol-Client describes syntax of the |Sec-WebSocket-Protocol| header field value sent by the client to the server.

クライアントは、次の新たなヘッダを,サーバへのハンドシェイクにて送信できる: The following new header fields can be sent during the handshake from the client to the server:

Sec-WebSocket-Key = base64-value-non-empty
Sec-WebSocket-Extensions = extension-list
Sec-WebSocket-Protocol-Client = 1#token
Sec-WebSocket-Version-Client = version

base64-value-non-empty = (1*base64-data [ base64-padding ]) |
                          base64-padding
base64-data      = 4base64-character
base64-padding   = (2base64-character "==") |
                   (3base64-character "=")
base64-character = ALPHA | DIGIT | "+" | "/"
extension-list = 1#extension
extension = extension-token *( ";" extension-param )
extension-token  = registered-token
registered-token = token

extension-param  = token [ "=" (token | quoted-string) ]
    ; quoted-string 構文を利用する場合、
    ; quoted-string のエスケープ復元後の値は
    ; 'token' ABNF に適合しなければならない
NZDIGIT         = "1" | "2" | "3" | "4" | "5" | "6" |
                  "7" | "8" | "9"
version = DIGIT | (NZDIGIT DIGIT) |
          ("1" DIGIT DIGIT) | ("2" DIGIT DIGIT)
          ; 0 〜 255 の範囲に制限され, かつ先頭のゼロは不可。

サーバは、次の新たなヘッダを,クライアントへのハンドシェイクにて送信できる: The following new header fields can be sent during the handshake from the server to the client:

Sec-WebSocket-Extensions = extension-list
Sec-WebSocket-Accept     = base64-value-non-empty
Sec-WebSocket-Protocol-Server = token
Sec-WebSocket-Version-Server  = 1#version

4.4. 複数のバージョンの WebSocket Protocol のサポート

この節では、クライアントとサーバにおいて,複数のバージョンの WebSocket Protocol をサポートするための指針を提供する。 This section provides some guidance on supporting multiple versions of the WebSocket Protocol in clients and servers.

クライアントは、 WebSocket バージョン告知機能( Sec-WebSocket-Version ヘッダ)を利用して,希望する WebSocket Protocol のバージョンを(クライアントで最新にサポートされているものである必要はない)初期­時にリクエストできる。 サーバがリクエストされたバージョンをサポートし, かつ ハンドシェイク­メッセージの他の部分も妥当であれば、サーバはそのバージョンを受理することになる。 サーバがリクエストされたバージョンをサポートしない場合、利用を希望するすべてのバージョンを含んでいる Sec-WebSocket-Version ヘッダ(または複数の Sec-WebSocket-Version ヘッダ)により,応答しなければならない。 このとき,クライアントは、告知されたバージョンのいずれかをサポートするならば,新たなバージョン値を用いて WebSocket ハンドシェイクを繰り返すことができる。 Using the WebSocket version advertisement capability (the |Sec-WebSocket-Version| header field), a client can initially request the version of the WebSocket Protocol that it prefers (which doesn't necessarily have to be the latest supported by the client). If the server supports the requested version and the handshake message is otherwise valid, the server will accept that version. If the server doesn't support the requested version, it MUST respond with a |Sec-WebSocket-Version| header field (or multiple |Sec-WebSocket-Version| header fields) containing all versions it is willing to use. At this point, if the client supports one of the advertised versions, it can repeat the WebSocket handshake using a new version value.

上述のバージョン折衝の例を示す: The following example demonstrates version negotiation described above:

GET /chat HTTP/1.1
Host: server.example.com
Upgrade: websocket
Connection: Upgrade
...
Sec-WebSocket-Version: 25

サーバからの応答は次のような形をとり得る: The response from the server might look as follows:

HTTP/1.1 400 Bad Request
...
Sec-WebSocket-Version: 13, 8, 7

前記のサーバからの応答は次のような形もとり得ることに注意: Note that the last response from the server might also look like:

HTTP/1.1 400 Bad Request
...
Sec-WebSocket-Version: 13
Sec-WebSocket-Version: 8, 7

クライアントは、今度は,バージョン 13 に適合するハンドシェイクを繰り返す: The client now repeats the handshake that conforms to version 13:

GET /chat HTTP/1.1
Host: server.example.com
Upgrade: websocket
Connection: Upgrade
...
Sec-WebSocket-Version: 13

5. データのフレーミング

5.1. 概観

WebSocket Protocol においては,データはフレームの並びにより伝送される。 (透過型プロキシなどの)ネットワーク中継点による混同を回避するため,および 10.3 節 にて更に論じられるセキュリティ上の理由から、クライアントは,サーバに向けて送信するすべてのフレームをマスクしなければならない (更なる詳細は 5.3 節 を見よ)。 (マスクの適用は WebSocket Protocol が TLS を通して実行されているかどうかに関係なく行われることに注意。) サーバは、マスクされていないフレームを受信した際には,接続を close しなければならない。 この場合,サーバは、 7.4.1 節 の定義に従って,ステータスコード 1002 (プロトコル­エラー)を伴う Close フレームを送信してもよい。 サーバは、クライアントに送信するどのフレームもマスクしてはならない。 クライアントは、マスクされたフレームを検出したときには,接続を close しなければならない。 この場合、 7.4.1 節 に定義されるステータスコード 1002 (プロトコル­エラー)を用いてもよい。 (これらの規則は、将来­仕様においては,緩和され得る。) In the WebSocket Protocol, data is transmitted using a sequence of frames. To avoid confusing network intermediaries (such as intercepting proxies) and for security reasons that are further discussed in Section 10.3, a client MUST mask all frames that it sends to the server (see Section 5.3 for further details). (Note that masking is done whether or not the WebSocket Protocol is running over TLS.) The server MUST close the connection upon receiving a frame that is not masked. In this case, a server MAY send a Close frame with a status code of 1002 (protocol error) as defined in Section 7.4.1. A server MUST NOT mask any frames that it sends to the client. A client MUST close a connection if it detects a masked frame. In this case, it MAY use the status code 1002 (protocol error) as defined in Section 7.4.1. (These rules might be relaxed in a future specification.)

フレーミング プロトコルの基礎部は、 opcode によるフレームの種別, およびペイロードの長さを定義し, Extension データApplication データ(および,この2つを併せた Payload データ)が占める指定域を定義する。 一部のビットと opcode は、プロトコルの将来の発展のために予約済みである。 The base framing protocol defines a frame type with an opcode, a payload length, and designated locations for "Extension data" and "Application data", which together define the "Payload data". Certain bits and opcodes are reserved for future expansion of the protocol.

データ­フレームは、クライアントとサーバのいずれからでも, opening ハンドシェイクの完了後から その端点が Close フレーム( 5.5.1 節 )を送信し終える前までのいつでも,伝送されてよい A data frame MAY be transmitted by either the client or the server at any time after opening handshake completion and before that endpoint has sent a Close frame (Section 5.5.1).

5.2. フレーミング プロトコルの基礎部

データ転送パートのための伝送路データ形式は、この節にて ABNF [RFC5234] を用いて詳細に渡り述べられる。 (この文書の他の節と異なり,この節の ABNF はビットのグループを対象にしていることに注意。 各グループのビット長はコメント内に指示される。 伝送路­上に符号化される際の最上位ビットは、 ABNF においては左端に位置する。) フレーミングのより高次の概観は次の図により与えられる。 この図とこの節の以下で指定される ABNF との間に不一致がある場合、この図の方が優先される。 This wire format for the data transfer part is described by the ABNF [RFC5234] given in detail in this section. (Note that, unlike in other sections of this document, the ABNF in this section is operating on groups of bits. The length of each group of bits is indicated in a comment. When encoded on the wire, the most significant bit is the leftmost in the ABNF). A high-level overview of the framing is given in the following figure. In a case of conflict between the figure below and the ABNF specified later in this section, the figure is authoritative.

0 1 2 3
0123456789 0123456789 0123456789 01
F
I
N
R
S
V
1
R
S
V
2
R
S
V
3
opcode
(4 bit)
M
A
S
K
Payload 長
(7 bit)
延長 Payload 長
(16/64 bit)
( Payload 長 == 126/127 の場合)
延長 Payload 長(続き),( Payload 長 ==
127 の場合) Masking-key ( MASK が 1 の場合)
Masking-key (続き) Payload データ
Payload データ(続き)
Payload データ(続き)
0                   1                   2                   3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-------+-+-------------+-------------------------------+
|F|R|R|R| opcode|M| Payload len |    Extended payload length    |
|I|S|S|S|  (4)  |A|     (7)     |             (16/64)           |
|N|V|V|V|       |S|             |   (if payload len==126/127)   |
| |1|2|3|       |K|             |                               |
+-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
|     Extended payload length continued, if payload len == 127  |
+ - - - - - - - - - - - - - - - +-------------------------------+
|                               |Masking-key, if MASK set to 1  |
+-------------------------------+-------------------------------+
| Masking-key (continued)       |          Payload Data         |
+-------------------------------- - - - - - - - - - - - - - - - +
:                     Payload Data continued ...                :
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
|                     Payload Data continued ...                |
+---------------------------------------------------------------+
FIN: 1 ビット
メッセージの中の最後の断片である( 1 の場合)かどうかを指示する。 最初の断片が最後の断片になっていてもよい Indicates that this is the final fragment in a message. The first fragment MAY also be the final fragment.
RSV1, RSV2, RSV3: 各 1 ビット 【“予約済みビット”】
非ゼロ値に対する意味を定義する拡張が折衝されていない限り、 0 でなければならない。 非ゼロ値が受信されたにも関わらず,折衝されたどの拡張もそのような非ゼロ値の意味を定義していない場合、受信した側の端点は, WebSocket 接続を失敗させ なければならない MUST be 0 unless an extension is negotiated that defines meanings for non-zero values. If a nonzero value is received and none of the negotiated extensions defines the meaning of such a nonzero value, the receiving endpoint MUST _Fail the WebSocket Connection_.
opcode: 4 ビット
Payload データの解釈を定義する。 未知の opcode が受信された場合、受信­側 端点は WebSocket 接続を失敗させ なければならない Defines the interpretation of the "Payload data". If an unknown opcode is received, the receiving endpoint MUST _Fail the WebSocket Connection_. The following values are defined.

次の値が定義されている:

  • %x0 は継続フレームを表す %x0 denotes a continuation frame
  • %x1 はテキスト­フレームを表す %x1 denotes a text frame
  • %x2 はバイナリ­フレームを表す %x2 denotes a binary frame
  • %x3-7 は追加の非­制御フレーム用に予約済み %x3-7 are reserved for further non-control frames
  • %x8 は接続の close を表す %x8 denotes a connection close
  • %x9 は ping を表す %x9 denotes a ping
  • %xA は pong を表す %xA denotes a pong
  • %xB-F は追加の制御フレーム用に予約済み %xB-F are reserved for further control frames
Mask: 1 ビット
Payload データがマスクされているかどうかを定義する。 1 にされている場合、 Masking-key の中にマスキングキーが在り、 5.3 節 に従って, Payload データのマスクを解除する際に用いられる。 クライアントからサーバへ送信される すべてのフレームにおいて、このビットは 1 にされる。 Defines whether the "Payload data" is masked. If set to 1, a masking key is present in masking-key, and this is used to unmask the "Payload data" as per Section 5.3. All frames sent from client to server have this bit set to 1.
Payload 長: 7, 7+16, 7+64 ビットのいずれか
バイト数による Payload データの長さ: 0 〜 125 の場合、それがそのままペイロードの長さになる。 126 の場合、後続の 2 バイトが 16 ビット非負­整数に解釈されてペイロードの長さになる。 127 の場合、後続の 8 バイトが 64 ビット非負­整数(最上位ビットは 0 でなければならない)に解釈されてペイロードの長さになる。 複バイトによる長さ数量はネットワーク­バイト順序で表記される。 いかなる場合も、長さの符号化には最小のバイト数が用いられなければならないことに注意。 例えば, 124 バイトの文字列に対し、その長さが 126, 0, 124 の並びに符号化されることはない。 ペイロードの長さは、 Extension データの長さと Application データの長さの和である。 Extension データの長さはゼロもあり得る。 この場合のペイロードの長さは Application データの長さになる。 The length of the "Payload data", in bytes: if 0-125, that is the payload length. If 126, the following 2 bytes interpreted as a 16-bit unsigned integer are the payload length. If 127, the following 8 bytes interpreted as a 64-bit unsigned integer (the most significant bit MUST be 0) are the payload length. Multibyte length quantities are expressed in network byte order. Note that in all cases, the minimal number of bytes MUST be used to encode the length, for example, the length of a 124-byte-long string can't be encoded as the sequence 126, 0, 124. The payload length is the length of the "Extension data" + the length of the "Application data". The length of the "Extension data" may be zero, in which case the payload length is the length of the "Application data".
Masking-key: 0 バイトまたは 4 バイト
クライアントからサーバへ送信されるすべてのフレームは、フレーム内に含められた 32 ビット値によりマスクされる。 マスク­ビットが 1 にされている場合、このフィールドが在る。 マスク­ビットが 0 にされている場合、このフィールドは無い。 クライアントからサーバへのマスクの適用についての詳細は 5.3 節 を見よ。 All frames sent from the client to the server are masked by a 32-bit value that is contained within the frame. This field is present if the mask bit is set to 1 and is absent if the mask bit is set to 0. See Section 5.3 for further information on client-to-server masking.
Payload データ: ( x + y ) バイト
Payload データは、 Extension データApplication データを連結したものとして定義される。 The "Payload data" is defined as "Extension data" concatenated with "Application data".
Extension データ: x バイト
Extension データは、拡張が折衝されていない限り, 0 バイトになる。 どの拡張も Extension データの長さ, または その算出方法を指定しなければならず,かつ 拡張がそれをどのように利用するかが opening ハンドシェイクの間に折衝されなければならない 在る場合、 Extension データの長さは,総ペイロード長に内包される。 The "Extension data" is 0 bytes unless an extension has been negotiated. Any extension MUST specify the length of the "Extension data", or how that length may be calculated, and how the extension use MUST be negotiated during the opening handshake. If present, the "Extension data" is included in the total payload length.
Application データ: y バイト
Extension データの後のフレームの残りの部分を占める任意の Application データApplication データの長さはペイロードの長さから Extension データの長さを引いたものに等しい。 Arbitrary "Application data", taking up the remainder of the frame after any "Extension data". The length of the "Application data" is equal to the payload length minus the length of the "Extension data".

フレーミング プロトコルの基礎部は、次の ABNF [RFC5234] により形式的に定義される。 このデータの表現はバイナリであり, ASCII 文字でないことに注意。 したがって,値 %x0 または %x1 をとる長さ 1 ビットのフィールドは、ASCII 符号化方式(文字 "0" または "1" )による全部的バイト(オクテット)ではなく,値 0 または 1 をとる単独のビットで表現される。 値 %x0-F をとる長さ 4 ビットのフィールドもまた、これらの値をとる ASCII 文字や全部的バイト(オクテット)ではなく, 4 ビットで表現される。 [RFC5234] は、文字­符号化方式を指定しない: The base framing protocol is formally defined by the following ABNF [RFC5234]. It is important to note that the representation of this data is binary, not ASCII characters. As such, a field with a length of 1 bit that takes values %x0 / %x1 is represented as a single bit whose value is 0 or 1, not a full byte (octet) that stands for the characters "0" or "1" in the ASCII encoding. A field with a length of 4 bits with values between %x0-F again is represented by 4 bits, again NOT by an ASCII character or full byte (octet) with these values. [RFC5234] does not specify a character encoding:

“終端値の並び( string )に解決される規則は、文字の列( characters )と呼ばれることがある。 ABNF においては、各­文字は単なる非負­整数である。 ある種の文脈においては、値から文字集合( ASCII など)への特定の写像(符号化方式)が指定されることになる。” "Rules resolve into a string of terminal values, sometimes called characters. In ABNF, a character is merely a non-negative integer. In certain contexts, a specific mapping (encoding) of values into a character set (such as ASCII) will be specified."

ここで指定される符号化方式は、各­終端値が符号化される際のビット数が,各フィールドごとに異なり得るものとして指定される、バイナリ符号化方式である。 Here, the specified encoding is a binary encoding where each terminal value is encoded in the specified number of bits, which varies for each field.

ws-frame                = frame-fin           ; 長さ 1 ビット
                          frame-rsv1          ; 長さ 1 ビット
                          frame-rsv2          ; 長さ 1 ビット
                          frame-rsv3          ; 長さ 1 ビット
                          frame-opcode        ; 長さ 4 ビット
                          frame-masked        ; 長さ 1 ビット
                          frame-payload-length
                          ; 長さ 7, 7+16, 7+64 ビットいずれか

                          [ frame-masking-key ]  ; 長さ 32 ビット
                          frame-payload-data
                          ; 長さ n×8 ビット ( n >= 0 )

frame-fin               = %x0 ; このメッセージの後続フレームがある
                        / %x1 ; このメッセージの最後のフレーム
                              ; 長さ 1 ビット

frame-rsv1              = %x0 / %x1
                          ; 長さ 1 ビット,拡張が折衝されて
                          ; いない限り 0 でなければならない

frame-rsv2              = %x0 / %x1
                          ; 長さ 1 ビット,拡張が折衝されて
                          ; いない限り 0 でなければならない

frame-rsv3              = %x0 / %x1
                          ; 長さ 1 ビット,拡張が折衝されて
                          ; いない限り 0 でなければならない

frame-opcode            = frame-opcode-non-control /
                          frame-opcode-control /
                          frame-opcode-cont

frame-opcode-cont       = %x0 ; 継続フレーム

frame-opcode-non-control= %x1 ; テキスト­フレーム
                        / %x2 ; バイナリ­フレーム
                        / %x3-7 ; 更なる非­制御フレーム用に予約済み
                                ; 長さ 4 ビット

frame-opcode-control    = %x8 ; 接続の close
                        / %x9 ; ping
                        / %xA ; pong
                        / %xB-F ; 更なる制御フレーム用に予約済み
                                ; 長さ 4 ビット

frame-masked            = %x0
                        ; フレームはマスクされていない,frame-masking-key は無い
                        / %x1
                        ; フレームはマスク済み,frame-masking-key は在る
                        ; 長さ 1 ビット

frame-payload-length    = ( %x00-7D )
                        / ( %x7E frame-payload-length-16 )
                        / ( %x7F frame-payload-length-63 )
                        ; 長さ 7, 7+16, 7+64 ビットいずれか(同順)

frame-payload-length-16 = %x0000-FFFF ; 長さ 16 ビット

frame-payload-length-63 = %x0000000000000000-7FFFFFFFFFFFFFFF
                        ; 長さ 64 ビット

frame-masking-key       = 4( %x00-FF )
                        ; frame-masked が 1 のときのみ在る
                        ; 長さ 32 ビット

frame-payload-data      = (frame-masked-extension-data
                           frame-masked-application-data)
                        ; frame-masked が 1 のとき
                          / (frame-unmasked-extension-data
                            frame-unmasked-application-data)
                        ; frame-masked が 0 のとき

frame-masked-extension-data     = *( %x00-FF )
                        ; 将来の拡張性のために予約済み
                        ; 長さ n×8 ビット ( n >= 0 )

frame-masked-application-data   = *( %x00-FF )
                        ; 長さ n×8 ビット ( n >= 0 )

frame-unmasked-extension-data   = *( %x00-FF )
                        ; 将来の拡張性のために予約済み
                        ; 長さ n×8 ビット ( n >= 0 )

frame-unmasked-application-data = *( %x00-FF )
                        ; 長さ n×8 ビット ( n >= 0 )

5.3. クライアントからサーバへのマスクの適用

マスクされたフレームでは、 5.2 節 の定義に従って, frame-masked フィールドが 1 にされていなければならない A masked frame MUST have the field frame-masked set to 1, as defined in Section 5.2.

5.2 節 にて定義したように、マスキングキーは,そのフレーム内に frame-masking-key として完全に含まれる。 それは、同じ節で Extension データApplication データを内包する Payload データとして定義された, frame-payload-data を,マスクするために用いられる。 The masking key is contained completely within the frame, as defined in Section 5.2 as frame-masking-key. It is used to mask the "Payload data" defined in the same section as frame-payload-data, which includes "Extension data" and "Application data".

マスキングキーは、クライアントにより無作為に選ばれる 32 ビット値である。 マスクされたフレームを準備する際には、クライアントは、許容される 32 ビット値の集合から,新規にマスキングキーを取り出さなければならない。 マスキングキーは予測不能になる必要がある。 したがって、マスキングキーは,平均情報量( entropy )の強い源から導出されなければならず、与えられたフレームに対するマスキングキーからの, 後続のフレームに対するマスキングキーの予測が,サーバやプロキシにとって容易になってはならない。 マスキングキーの予測不能性は、悪意のあるアプリケーションの作者が伝送路­上に現れるバイトを選定できなくするために,本質的である。 セキュリティに敏感なアプリケーションにとり,情報量の源として相応しいとされるものについては、 [RFC4086] にて論じられている。 The masking key is a 32-bit value chosen at random by the client. When preparing a masked frame, the client MUST pick a fresh masking key from the set of allowed 32-bit values. The masking key needs to be unpredictable; thus, the masking key MUST be derived from a strong source of entropy, and the masking key for a given frame MUST NOT make it simple for a server/proxy to predict the masking key for a subsequent frame. The unpredictability of the masking key is essential to prevent authors of malicious applications from selecting the bytes that appear on the wire. RFC 4086 [RFC4086] discusses what entails a suitable source of entropy for security-sensitive applications.

マスクの適用は Payload データの長さには影響しない。 マスクされたデータからマスクされていないデータへの, あるいはその逆への変換には、次のアルゴリズムが適用される。 変換には、その向きに関係なく,同じアルゴリズムが適用される。 すなわち、同じ手続きが,データに対するマスクの適用と解除のいずれにも,適用される。 The masking does not affect the length of the "Payload data". To convert masked data into unmasked data, or vice versa, the following algorithm is applied. The same algorithm applies regardless of the direction of the translation, e.g., the same steps are applied to mask the data as to unmask the data.

変換­後のデータの i 番目のオクテット( "transformed-octet-i", 0 番目が最初)は、元データの i 番目のオクテット( "original-octet-i" )と, マスキングキーの i modulo 4 番目に位置するオクテット( "masking-key-octet-j" )との XOR (排他的論理和)である: Octet i of the transformed data ("transformed-octet-i") is the XOR of octet i of the original data ("original-octet-i") with octet at index i modulo 4 of the masking key ("masking-key-octet-j"):

j                   = i MOD 4
transformed-octet-i = original-octet-i XOR masking-key-octet-j

フレーミングの中で frame-payload-length により指示されるペイロードの長さは、マスキングキーの長さを内包しない。 それは、 Payload データの長さであり,マスキングキーに後続するバイトの個数である。 The payload length, indicated in the framing as frame-payload-length, does NOT include the length of the masking key. It is the length of the "Payload data", e.g., the number of bytes following the masking key.

5.4. 断片化

断片化の主な目的は、メッセージが開始される際に,メッセージのバッファを要することなく,未知サイズのメッセージを送信できるようにする所にある。 仮にメッセージを断片化できないとした場合、端点は,最初のバイトが送信される前にその長さを数え上げるため, メッセージ全体をバッファしなければならなくなる。 断片化が可能であれば、サーバや中継点は、バッファを適度なサイズにした上で,バッファが満杯になり次第, 断片をネットワークに書き出せるようになる。 The primary purpose of fragmentation is to allow sending a message that is of unknown size when the message is started without having to buffer that message. If messages couldn't be fragmented, then an endpoint would have to buffer the entire message so its length could be counted before the first byte is sent. With fragmentation, a server or intermediary may choose a reasonable size buffer and, when the buffer is full, write a fragment to the network.

断片化の第二のユースケースは、多重化にある。 巨大なメッセージを1個の論理チャンネル上に流して,出力チャンネルを占有させるのは好ましくないので。 多重化においては、出力チャンネルの共有を適化できるように,メッセージをより小さな断片に自由に分割できる必要がある。 (この文書では多重化­拡張については述べられないことに注意。) A secondary use-case for fragmentation is for multiplexing, where it is not desirable for a large message on one logical channel to monopolize the output channel, so the multiplexing needs to be free to split the message into smaller fragments to better share the output channel. (Note that the multiplexing extension is not described in this document.)

拡張から特に指定されない限り,フレーム【断片­化のされ方】は意味論を持たない。 中継点は、拡張がクライアント↔サーバ間で折衝されていない場合、あるいは何らかの拡張が折衝されていても,中継点が 折衝されているすべての拡張について解せる, かつ これらの拡張の存在下においてフレームの合併や分割の仕方を知っている場合は、フレームの合併や分割を行い得る。 このことから、拡張の不在の下では,送信側と受信側は, 特定のフレーム境界の有無に依存してはならないことになる。 Unless specified otherwise by an extension, frames have no semantic meaning. An intermediary might coalesce and/or split frames, if no extensions were negotiated by the client and the server or if some extensions were negotiated, but the intermediary understood all the extensions negotiated and knows how to coalesce and/or split frames in the presence of these extensions. One implication of this is that in absence of extensions, senders and receivers must not depend on the presence of specific frame boundaries.

次の規則が断片化に適用される: The following rules apply to fragmentation:

  • 断片化されていないメッセージは、 FIN ビットがセットされ( 5.2 節 ), opcode が 0 以外にされた,単独のフレームからなる。 An unfragmented message consists of a single frame with the FIN bit set (Section 5.2) and an opcode other than 0.
  • 断片化されたメッセージは、 FIN ビットがクリアされ, opcode が 0 以外にされた,1個のフレームから始まり、 FIN ビットがクリアされ, opcode が 0 にされた,0個以上のフレームが後続し、 FIN ビットがセットされ, opcode が 0 にされた,1個のフレームで終了する。 断片化されたメッセージは、概念的には、断片のペイロードを順に連結したペイロードを持つ,単独のより大きなメッセージと等価である。 しかしながら,拡張の存在下では、拡張が Extension データの解釈を定義するので,これは成り立たない。 例えば、 Extension データが最初の断片にのみ在って,後続の断片にも適用されるかもしれないし、それぞれの断片ごとに,その断片のみに適用される Extension データが在るかもしれない。 Extension データが不在の場合の断片化の様態を次の例に示す: A fragmented message consists of a single frame with the FIN bit clear and an opcode other than 0, followed by zero or more frames with the FIN bit clear and the opcode set to 0, and terminated by a single frame with the FIN bit set and an opcode of 0. A fragmented message is conceptually equivalent to a single larger message whose payload is equal to the concatenation of the payloads of the fragments in order; however, in the presence of extensions, this may not hold true as the extension defines the interpretation of the "Extension data" present. For instance, "Extension data" may only be present at the beginning of the first fragment and apply to subsequent fragments, or there may be "Extension data" present in each of the fragments that applies only to that particular fragment. In the absence of "Extension data", the following example demonstrates how fragmentation works.

    例: 3個の断片として送信されるテキスト メッセージにおいては、 最初の断片は opcode が 0x1 に, FIN ビットはクリアされ、 2番目の断片は opcode が 0x0 に, FIN ビットはクリアされ、 3番目の断片は opcode が 0x0 に, FIN ビットはセットされることになる。 EXAMPLE: For a text message sent as three fragments, the first fragment would have an opcode of 0x1 and a FIN bit clear, the second fragment would have an opcode of 0x0 and a FIN bit clear, and the third fragment would have an opcode of 0x0 and a FIN bit that is set.

  • 断片化されたメッセージの合間に制御フレーム( 5.5 節 を見よ)が挿入されてもよい。 制御フレーム自身は断片化されてはならない Control frames (see Section 5.5) MAY be injected in the middle of a fragmented message. Control frames themselves MUST NOT be fragmented.
  • メッセージの断片は、送信側から送信された順序で受信先に送達されなければならない Message fragments MUST be delivered to the recipient in the order sent by the sender.
  • あるメッセージに属するいくつかの断片と別のメッセージに属するいくつかの断片とが、互いに交互挿入されてはならない。 ただし、拡張が折衝されていて,それにより交互挿入が解釈可能になっている場合を除く。 The fragments of one message MUST NOT be interleaved between the fragments of another message unless an extension has been negotiated that can interpret the interleaving.
  • 端点は、断片化されたメッセージの合間に挟まれた制御フレームを取り扱えなければならない An endpoint MUST be capable of handling control frames in the middle of a fragmented message.
  • 送信側は、非­制御メッセージに対しては,任意サイズの断片を作成してよい A sender MAY create fragments of any size for non-control messages.
  • クライアントとサーバは、断片化されたメッセージと断片化されていないメッセージのいずれの受信もサポートしなければならない Clients and servers MUST support receiving both fragmented and unfragmented messages.
  • 制御フレームは断片化され得ないので、中継点は、制御フレームの断片化の様態に変更を試みてはならない As control frames cannot be fragmented, an intermediary MUST NOT attempt to change the fragmentation of a control frame.
  • 中継点は、いずれかの予約済みビット値が用いられていて, かつ これらの値の意味を知らない場合、メッセージの断片化の様態を変更してはならない An intermediary MUST NOT change the fragmentation of a message if any reserved bit values are used and the meaning of these values is not known to the intermediary.
  • 中継点は、拡張が折衝されていて, かつ 折衝された拡張の意味論に通じていないならば、接続の文脈下のどのメッセージの断片化の様態も変更してはならない。 同様に, WebSocket 接続により生じた WebSocket ハンドシェイクを見ない(したがって、その内容についても通知されていない)中継点は、その種の接続のどのメッセージの断片化の様態も変更してはならない An intermediary MUST NOT change the fragmentation of any message in the context of a connection where extensions have been negotiated and the intermediary is not aware of the semantics of the negotiated extensions. Similarly, an intermediary that didn't see the WebSocket handshake (and wasn't notified about its content) that resulted in a WebSocket connection MUST NOT change the fragmentation of any message of such connection.
  • これらの規則の帰結として、同じメッセージに属する すべての断片の種別は,それらの最初の断片の opcode で設定された種別と同じに揃うことになる。 制御フレームは断片化できないので、同じメッセージに属するすべての断片の種別は、[ テキスト, バイナリ, [ いずれかの予約済み opcode ]]のいずれかに揃えられなければならない As a consequence of these rules, all fragments of a message are of the same type, as set by the first fragment's opcode. Since control frames cannot be fragmented, the type for all fragments in a message MUST be either text, binary, or one of the reserved opcodes.

注記: 仮に制御フレームを挿入できないとした場合、例えば, ping の待ち時間は、大きいメッセージの背後に回されたときに不必要に長くされる。 それゆえ、断片化されたメッセージの合間に挟まれた制御フレームの取り扱いも要件にされている。 NOTE: If control frames could not be interjected, the latency of a ping, for example, would be very long if behind a large message. Hence, the requirement of handling control frames in the middle of a fragmented message.

実装に対する注記: 拡張の不在の下では、受信側はフレーム全体をバッファしなくても処理できる。 例えば,ストリーミング API が用いられている場合、フレームの一部をアプリケーションに送達できる。 しかしながら、この前提は,将来のどの WebSocket 拡張においても成立するとは限らないことに注意。 IMPLEMENTATION NOTE: In the absence of any extension, a receiver doesn't have to buffer the whole frame in order to process it. For example, if a streaming API is used, a part of a frame can be delivered to the application. However, note that this assumption might not hold true for all future WebSocket extensions.

5.5. 制御フレーム

制御フレームは, opcode の最上位ビットが 1 かどうかで識別される。 制御フレームに対し現時点で定義済みの opcode には、 0x8 ( Close ), 0x9 ( Ping ), 0xA ( Pong )がある。 0xB 〜 0xF の opcode はまだ定義されていないが、追加の制御フレームのために予約済みである。 Control frames are identified by opcodes where the most significant bit of the opcode is 1. Currently defined opcodes for control frames include 0x8 (Close), 0x9 (Ping), and 0xA (Pong). Opcodes 0xB-0xF are reserved for further control frames yet to be defined.

制御フレームは,WebSocket の状態について通信するために用いられる。 制御フレームは,断片化されたメッセージの合間に挿入できる。 Control frames are used to communicate state about the WebSocket. Control frames can be interjected in the middle of a fragmented message.

すべての制御フレームは、ペイロードの長さが 125 バイト以下でなければならず,断片化されてはならない All control frames MUST have a payload length of 125 bytes or less and MUST NOT be fragmented.

5.5.1. Close

Close フレームは opcode 0x8 を持つ。 The Close frame contains an opcode of 0x8.

Close フレームは, closing の事由を指示するボディ(フレームの Application データ部分)を含んでもよい。 例えば: 端点がシャットダウン中にある, 端点が大き過ぎるフレームを受信している, 端点が予期される形式に適合していないフレームを受信した,等々。 ボディが存在する場合、ボディの最初の2バイトは、 7.4 節 にて定義される code 値をとるステータスコードを表現する,(ネットワーク­バイト順序で)2 バイトの非負­整数でなければならない。 2 バイト整数に後続して、ボディには, UTF-8 符号化された reason 値のデータが含まれていてもよい。 その解釈はこの仕様では定義されない。 このデータは、人が読めるようにされる必要はないが,デバッグや問題に関わる情報を接続を open したスクリプトに渡すのには有用になり得る。 このデータは 人から読めるものになっている保証はないので、クライアントは末端­利用者にそれを示してはならない The Close frame MAY contain a body (the "Application data" portion of the frame) that indicates a reason for closing, such as an endpoint shutting down, an endpoint having received a frame too large, or an endpoint having received a frame that does not conform to the format expected by the endpoint. If there is a body, the first two bytes of the body MUST be a 2-byte unsigned integer (in network byte order) representing a status code with value /code/ defined in Section 7.4. Following the 2-byte integer, the body MAY contain UTF-8-encoded data with value /reason/, the interpretation of which is not defined by this specification. This data is not necessarily human readable but may be useful for debugging or passing information relevant to the script that opened the connection. As the data is not guaranteed to be human readable, clients MUST NOT show it to end users.

クライアントからサーバへ送信される Close フレームは、 5.3 節 に従ってマスクされなければならない。 Close frames sent from client to server must be masked as per Section 5.3.

アプリケーションは、 Close フレームを送信した後は,それ以上データ­フレームを送信してはならない The application MUST NOT send any more data frames after sending a Close frame.

Close フレームを受信した端点は、その前に Close フレームを送信していなかったならば,応答として Close フレームを送信しなければならない。 (概して,応答として Close フレームを送信する際は、端点は受信したステータスコードを返す。) 行い得る限り早くするべきである。 端点は、現在のメッセージの送信を終えるまで, Close フレームの送信を遅延してもよい。 (例えば,断片化されたメッセージの大部分をすでに送信していた場合、端点は Close フレームを送信する前に残りの断片を送信してもよい)。 しかしながら,すでに Close フレームを送信した相手側の端点がデータの処理を続行する保証はない。 If an endpoint receives a Close frame and did not previously send a Close frame, the endpoint MUST send a Close frame in response. (When sending a Close frame in response, the endpoint typically echos the status code it received.) It SHOULD do so as soon as practical. An endpoint MAY delay sending a Close frame until its current message is sent (for instance, if the majority of a fragmented message is already sent, an endpoint MAY send the remaining fragments before sending a Close frame). However, there is no guarantee that the endpoint that has already sent a Close frame will continue to process data.

Close メッセージの送信と受信の両方を終えた端点は、 WebSocket 接続は close されたものと見なして, 下層の TCP 接続を close しなければならない。 サーバは、下層の TCP 接続を即時に close しなければならない。 クライアントは、サーバが接続を close するまで待機するべきであるが、例えばサーバからの TCP Close を適度な時間内に受信できなかったときなど, Close メッセージの送信と受信を終えた後に,いつでも接続を close してよい After both sending and receiving a Close message, an endpoint considers the WebSocket connection closed and MUST close the underlying TCP connection. The server MUST close the underlying TCP connection immediately; the client SHOULD wait for the server to close the connection but MAY close the connection at any time after sending and receiving a Close message, e.g., if it has not received a TCP Close from the server in a reasonable time period.

クライアントとサーバの双方が同時に Close メッセージを送信した場合、いずれの端点も Close メッセージを送信し,受信することになる。 この場合も WebSocket 接続が close されたものと見なして,下層の TCP 接続を close すべきである。 If a client and server both send a Close message at the same time, both endpoints will have sent and received a Close message and should consider the WebSocket connection closed and close the underlying TCP connection.

5.5.2. Ping

Ping フレームは opcode 0x9 を持つ。 The Ping frame contains an opcode of 0x9.

Ping フレームは Application データを内包してもよい A Ping frame MAY include "Application data".

端点が Ping フレームを受領した際には、すでに Close フレームを受信していない限り,応答として Pong フレームを送信しなければならない。 行い得る限り早く, Pong フレームで応答するべきである。 Pong フレームについては 5.5.3 節 にて論じられる。 Upon receipt of a Ping frame, an endpoint MUST send a Pong frame in response, unless it already received a Close frame. It SHOULD respond with Pong frame as soon as is practical. Pong frames are discussed in Section 5.5.3.

端点は、接続が確立されてから,接続が close されるまで、いつでも, Ping フレームを送信してよい An endpoint MAY send a Ping frame any time after the connection is established and before the connection is closed.

注記: Ping フレームは、接続維持( keepalive ), あるいはリモートの端点がまだ応答可能かどうかの検証に用をなし得る。 NOTE: A Ping frame may serve either as a keepalive or as a means to verify that the remote endpoint is still responsive.

5.5.3. Pong

Pong フレームは opcode 0xA を持つ。 The Pong frame contains an opcode of 0xA.

Ping および Pong フレームに適用される要件の詳細は 5.5.2 節 に述べられている。 Section 5.5.2 details requirements that apply to both Ping and Pong frames.

Ping フレームに対する応答として送信される Pong フレームの Application データは、返信­対象の Ping フレームのメッセージ­ボディのそれと同一でなければならない。 A Pong frame sent in response to a Ping frame must have identical "Application data" as found in the message body of the Ping frame being replied to.

Ping フレームを受信した端点は、より以前の Ping フレームに対する Pong フレームをまだ応答として送信していない場合、直近に処理された Ping フレームに対する Pong フレームのみの送信を採択してもよい If an endpoint receives a Ping frame and has not yet sent Pong frame(s) in response to previous Ping frame(s), the endpoint MAY elect to send a Pong frame for only the most recently processed Ping frame.

Pong フレームは,請求が無いときに送信されてもよい。 これは、単方向の鼓動として機能する。 請求されていない Pong フレームに対する応答は予期されていない。 A Pong frame MAY be sent unsolicited. This serves as a unidirectional heartbeat. A response to an unsolicited Pong frame is not expected.

5.6. データ­フレーム

データ­フレーム(すなわち,非­制御フレーム)は、 opcode の最上位ビットが 0 かどうかで識別される。 現時点でデータ­フレームに定義されている opcode は、 0x1 ( Text ), 0x2 ( Binary ) 【 および 0x00 ( Continuation )† 】 である。 opcode 0x3 〜 0x7 はまだ定義されていないが,追加の非­制御フレームのために予約済みである。 Data frames (e.g., non-control frames) are identified by opcodes where the most significant bit of the opcode is 0. Currently defined opcodes for data frames include 0x1 (Text), 0x2 (Binary). Opcodes 0x3-0x7 are reserved for further non-control frames yet to be defined.

データ­フレームはアプリケーション層や拡張­層のデータを運ぶ。 opcode はデータの解釈を決定する: Data frames carry application-layer and/or extension-layer data. The opcode determines the interpretation of the data:

Text
Payload データは UTF-8 に符号化されたテキスト­データである。 個々のテキスト­フレームは部分的な UTF-8 の並びを内包し得るが、メッセージ全体としては妥当な UTF-8 を含まなければならないことに注意。 再構築されたメッセージにおいて妥当でない UTF-8 は、 8.1 節 の記述に従って取り扱われる。 The "Payload data" is text data encoded as UTF-8. Note that a particular text frame might include a partial UTF-8 sequence; however, the whole message MUST contain valid UTF-8. Invalid UTF-8 in reassembled messages is handled as described in Section 8.1.
Binary
Payload データは任意のバイナリ­データであり、その解釈はもっぱら アプリケーション層に委ねられる。 The "Payload data" is arbitrary binary data whose interpretation is solely up to the application layer.
Continuation
【† この項目は, 正誤表による追加であり( Reported — まだ Verified ではない)、そこでは, “仕様の他所との整合性をとるためには、 Continuation フレーム(継続フレーム)は,データ­フレームに分類されるべき” と述べられている。 】
このフレーム( opcode 0x00 )には、常に,FIN ビットがクリアされた Text/Binary フレームが先行する( 5.2 節を見よ)。 Payload データは、同じメッセージの,直前に伝送された Text/Binary フレームの次の断片( 5.4 節を見よ)を包含し、メッセージの最初の断片と同じ仕方で解釈されなければならない These frames MUST be always preceeded by either Text or Binary frame with FIN bit clear (See Section 5.2). The "Payload data" contains next fragment (See section 5.4) of the message whose transmission were opened by the latest Text or Binary frame and MUST be interpreted in the same way as the initial fragment of the message. 】

5.7. 例

  • マスクされていないテキスト­メッセージを含む単独のフレーム: A single-frame unmasked text message

    0x81 0x05 0x48 0x65 0x6c 0x6c 0x6f ( "Hello" を含む)
  • マスクされたテキスト­メッセージを含む単独のフレーム: A single-frame masked text message

    0x81 0x85 0x37 0xfa 0x21 0x3d 0x7f 0x9f 0x4d 0x51 0x58 ( "Hello" を含む)
  • 断片化されたマスクされていないテキスト­メッセージ: A fragmented unmasked text message

    0x01 0x03 0x48 0x65 0x6c ( "Hel" を含む)
    0x80 0x02 0x6c 0x6f ( "lo" を含む)
  • マスクされていない Ping リクエストとマスクされた Ping Pong 応答: 正誤表による修正( Held for Document Update )】 Unmasked Ping request and masked PingPong response

    0x89 0x05 0x48 0x65 0x6c 0x6c 0x6f
    ( "Hello" をボディに含むが,ボディの中身は任意)
    0x8a 0x85 0x37 0xfa 0x21 0x3d 0x7f 0x9f 0x4d 0x51 0x58
    ( ping のボディに合致する "Hello" をボディに含む)
  • 256 バイトのバイナリ­メッセージを含む単独のマスクされていないフレーム: 256 bytes binary message in a single unmasked frame

    0x82 0x7E 0x0100 [256 バイトのバイナリ­データ]
  • 64Kb のバイナリ­メッセージを含む単独のマスクされていないフレーム: 64KiB binary message in a single unmasked frame

    0x82 0x7F 0x0000000000010000 [65536 バイトのバイナリ­データ]

5.8. 拡張性

このプロトコルは基本のプロトコルに機能を追加する拡張が許容されるように設計されている。 接続の端点は、利用する拡張があれば, opening ハンドシェイクの間に折衝しなければならない。 この仕様は、次のものを拡張­用途に提供する:

  • opcode 0x3 〜 0x7, 0xB 〜 0xF
  • Extension データフィールド
  • フレームヘッダの frame-rsv1, frame-rsv2, frame-rsv3 ビット 【“予約済みビット”】

拡張の折衝についての詳細は、 9.1 節 にて論じられる。 予想される拡張の利用の一部を以下に挙げる。 このリストは完全なものでも,規範的なものでもない。

The protocol is designed to allow for extensions, which will add capabilities to the base protocol. The endpoints of a connection MUST negotiate the use of any extensions during the opening handshake. This specification provides opcodes 0x3 through 0x7 and 0xB through 0xF, the "Extension data" field, and the frame-rsv1, frame-rsv2, and frame-rsv3 bits of the frame header for use by extensions. The negotiation of extensions is discussed in further detail in Section 9.1. Below are some anticipated uses of extensions. This list is neither complete nor prescriptive.
  • Extension データPayload データの中で Application データの前に置いてよい。 "Extension data" may be placed in the "Payload data" before the "Application data".
  • 予約済みビットはフレームごとに必要に応じて配分できる。 Reserved bits can be allocated for per-frame needs.
  • 予約済み opcode 値を定義できる。 Reserved opcode values can be defined.
  • より多くの opcode 値が必要であれば、予約済みビットを opcode フィールドに配分できる。 Reserved bits can be allocated to the opcode field if more opcode values are needed.
  • 予約済みビットや “拡張” opcode を、より大きな opcode やより多くのフレームごとのビットを定義するために, Payload データの外 【?】 に追加のビットを配分することにより、定義できる。 A reserved bit or an "extension" opcode can be defined that allocates additional bits out of the "Payload data" to define larger opcodes or more per-frame bits.

6. データの送信と受信

6.1. データの送信

WebSocket 接続を通して, data から構成される WebSocket メッセージを送信する ときは、端点は,次の手続きを行わなければならない To _Send a WebSocket Message_ comprising of /data/ over a WebSocket connection, an endpoint MUST perform the following steps.

  1. 端点は、 WebSocket 接続の OPEN 状態 を確保しなければならない4.1 節, 4.2.2 節 参照)。 いつの時点においても, WebSocket 接続の状態が変化した場合、端点は以下の手続きを中止しなければならない The endpoint MUST ensure the WebSocket connection is in the OPEN state (cf. Sections 4.1 and 4.2.2.) If at any point the state of the WebSocket connection changes, the endpoint MUST abort the following steps.
  2. 端点は、 WebSocket フレーム内の data5.2 節 の定義に従って,カプセル化しなければならない。 送信されるデータが大きいとき, あるいは 端点がデータ送信の開始を望む時点では まだデータ全体が可用になっていない場合、端点は,代わりに 5.4 節 の定義に従って,データを一連のフレームにカプセル化してもよい An endpoint MUST encapsulate the /data/ in a WebSocket frame as defined in Section 5.2. If the data to be sent is large or if the data is not available in its entirety at the point the endpoint wishes to begin sending the data, the endpoint MAY alternately encapsulate the data in a series of frames as defined in Section 5.4.
  3. データを含んでいる最初のフレームの opcode ( frame-opcode )は、テキストまたはバイナリ­データとして 受信先に解釈されることになるデータに適切な, 5.2 節 による値に設定されなければならない The opcode (frame-opcode) of the first frame containing the data MUST be set to the appropriate value from Section 5.2 for data that is to be interpreted by the recipient as text or binary data.
  4. データを含んでいる最後のフレームの FIN ビット( frame-fin )は、 5.2 節 の定義に従って, 1 にされなければならない The FIN bit (frame-fin) of the last frame containing the data MUST be set to 1 as defined in Section 5.2.
  5. データがクライアントから送信される場合、その各フレームは, 5.3 節 の定義に従って,マスクされなければならない If the data is being sent by the client, the frame(s) MUST be masked as defined in Section 5.3.
  6. WebSocket 接続において,何らかの拡張( 9 節 )が折衝されている場合、それらの拡張の定義に従って,追加の考慮点が適用され得る。 If any extensions (Section 9) have been negotiated for the WebSocket connection, additional considerations may apply as per the definition of those extensions.
  7. 形成済みの各フレームは、下層のネットワーク接続を通して伝送されなければならない The frame(s) that have been formed MUST be transmitted over the underlying network connection.

6.2. データの受信

端点は、 WebSocket データを受信するために,下層のネットワーク接続をリッスンする。 着信データは、 5.2 節 の定義に従って, WebSocket フレームとして構文解析されなければならない。 制御フレーム( 5.5 節 )が受信された際には、 5.5 節 の定義に従って,取り扱わなければならない。 端点は、データ­フレームの受信( 5.6 節 )に際し, 5.2 節 にて opcode ( frame-opcode )に定義された,データの type を記録しておかなければならない。 このフレームの Application データがメッセージの data として定義される。 フレームが断片化されていないメッセージ( 5.4 節 )を構成する場合、種別 type,データ dataWebSocket メッセージが受信された と言う。 フレームが断片化されたメッセージの一部である場合、 data を形成するために、後続のデータ­フレームからの Application データが連結される。 FIN ビット( frame-fin )で指示される最後の断片が受信されたとき、(断片の Application データの連結により構成される)データ data と(断片化されたメッセージの最初のフレームで記録された)種別 typeWebSocket メッセージが受信された と言う。 後続のデータ­フレームは、新たな WebSocket メッセージに属するものとして,解釈されなければならない To receive WebSocket data, an endpoint listens on the underlying network connection. Incoming data MUST be parsed as WebSocket frames as defined in Section 5.2. If a control frame (Section 5.5) is received, the frame MUST be handled as defined by Section 5.5. Upon receiving a data frame (Section 5.6), the endpoint MUST note the /type/ of the data as defined by the opcode (frame-opcode) from Section 5.2. The "Application data" from this frame is defined as the /data/ of the message. If the frame comprises an unfragmented message (Section 5.4), it is said that _A WebSocket Message Has Been Received_ with type /type/ and data /data/. If the frame is part of a fragmented message, the "Application data" of the subsequent data frames is concatenated to form the /data/. When the last fragment is received as indicated by the FIN bit (frame-fin), it is said that _A WebSocket Message Has Been Received_ with data /data/ (comprised of the concatenation of the "Application data" of the fragments) and type /type/ (noted from the first frame of the fragmented message). Subsequent data frames MUST be interpreted as belonging to a new WebSocket message.

拡張( 9 節 )は、特に何がメッセージ境界をなすのかも含めて,データの読み取り方の意味論を変更してもよい。 拡張は、ペイロードの中の Application データの前に Extension データを追加することに加えて, Application データに(圧縮などの)手を加えてもよい Extensions (Section 9) MAY change the semantics of how data is read, specifically including what comprises a message boundary. Extensions, in addition to adding "Extension data" before the "Application data" in a payload, MAY also modify the "Application data" (such as by compressing it).

サーバは、クライアントから受信したデータ­フレームのマスクを, 5.3 節 に従って除去しなければならない A server MUST remove masking for data frames received from a client as described in Section 5.3.

7. 接続の closing

7.1. 定義

7.1.1. WebSocket 接続を close する

WebSocket 接続を close するときは、端点は,下層の TCP 接続を close する。 端点は、 TLS セッションも含め, clean に TCP 接続を close するメソッドを用いるべきである。 適用可能ならば,受信された後続のバイトも破棄する。 端点は、攻撃されたときなど,どうしても必要ならば,接続を close してよい To _Close the WebSocket Connection_, an endpoint closes the underlying TCP connection. An endpoint SHOULD use a method that cleanly closes the TCP connection, as well as the TLS session, if applicable, discarding any trailing bytes that may have been received. An endpoint MAY close the connection via any means available when necessary, such as when under attack.

下層の TCP 接続は、ほとんどの通常の事例では,サーバが TIME_WAIT 状態を保持するようにするため、クライアントではなく,まずサーバから close されるべきである。 (これにより、最大セグメント寿命の2倍の期間( 2MSL — 2 maximum segment lifetime )、サーバは接続を再 open しないようになる, ~while より高い seq 番号による新たな SYN に際しては, TIME_WAIT 接続が即時に再 open されるので、対応するサーバへの影響は存在しない 【?】 )。 異常な事例においては(適度な時間内にサーバから TCP Close を受信していないときなど)クライアントから TCP Close を起動してもよい。 そのようなわけで、サーバが WebSocket 接続を close する 指示を受けたときは,即時に TCP Close を起動するべきであり、クライアントが同じ指示を受けたときは,サーバからの TCP Close を待機するべきである。 The underlying TCP connection, in most normal cases, SHOULD be closed first by the server, so that it holds the TIME_WAIT state and not the client (as this would prevent it from re-opening the connection for 2 maximum segment lifetimes (2MSL), while there is no corresponding server impact as a TIME_WAIT connection is immediately reopened upon a new SYN with a higher seq number). In abnormal cases (such as not having received a TCP Close from the server after a reasonable amount of time) a client MAY initiate the TCP Close. As such, when a server is instructed to _Close the WebSocket Connection_ it SHOULD initiate a TCP Close immediately, and when a client is instructed to do the same, it SHOULD wait for a TCP Close from the server.

Berkeley ソケットを利用して, clean な closure を得るための、 C 言語による例:

  1. SHUT_WR を引数に,ソケットに対し shutdown() を呼び出す。
  2. 値 0 が返されるまで, recv() を呼び出す。 (値 0 はピアがきちんと shutdown を行ったことを指示する)
  3. ソケットに対し close() を呼び出す。

As an example of how to obtain a clean closure in C using Berkeley sockets, one would call shutdown() with SHUT_WR on the socket, call recv() until obtaining a return value of 0 indicating that the peer has also performed an orderly shutdown, and finally call close() on the socket.

7.1.2. WebSocket closing ハンドシェイクを開始する

ステータスコード( 7.4 節code, および オプションの close 事由( 7.1.6 節reason をパラメタに WebSocket closing ハンドシェイクを開始する ときは、端点は 5.5.1 節 の記述に従って,ステータスコードが code にされ, close 事由が reason にされた, Close 制御フレームを送信しなければならない。 いったん,端点が Close 制御フレームを送信し, 受信したなら、その端点は 7.1.1 節 の定義に従って, WebSocket 接続を close する べきである。 To _Start the WebSocket Closing Handshake_ with a status code (Section 7.4) /code/ and an optional close reason (Section 7.1.6) /reason/, an endpoint MUST send a Close control frame, as described in Section 5.5.1, whose status code is set to /code/ and whose close reason is set to /reason/. Once an endpoint has both sent and received a Close control frame, that endpoint SHOULD _Close the WebSocket Connection_ as defined in Section 7.1.1.

7.1.3. WebSocket closing ハンドシェイクが開始された

Close 制御フレームを送信または受信したとき, WebSocket closing ハンドシェイクが開始された と言い、その WebSocket 接続は CLOSING 状態 に入る。 Upon either sending or receiving a Close control frame, it is said that _The WebSocket Closing Handshake is Started_ and that the WebSocket connection is in the CLOSING state.

7.1.4. WebSocket 接続が close された

下層の TCP 接続が close されたとき, WebSocket 接続は close された と言い、その WebSocket 接続は CLOSED 状態 に入る。 WebSocket closing ハンドシェイクの完了後, TCP 接続が close された場合、 WebSocket 接続は clean に close されたと言う。 When the underlying TCP connection is closed, it is said that _The WebSocket Connection is Closed_ and that the WebSocket connection is in the CLOSED state. If the TCP connection was closed after the WebSocket closing handshake was completed, the WebSocket connection is said to have been closed _cleanly_.

WebSocket 接続が確立できなかったときも WebSocket 接続は close された と言うが、 clean に とは言わない。 If the WebSocket connection could not be established, it is also said that _The WebSocket Connection is Closed_, but not _cleanly_.

7.1.5. WebSocket 接続の close コード

5.5.1 節, 7.4 節 にて定義されるように、 Close 制御フレームは, closure の事由を指示するステータスコードを含み得る。 WebSocket 接続の closing は,いずれの端点からも(同時の可能性も含めて)起動され得る。 WebSocket 接続の close コード は、このプロトコルを実装しているアプリケーションが最初に受信した Close 制御フレームに含まれているステータスコード( 7.4 節 )として定義される。 この Close 制御フレームがステータスコードを含んでいない場合、 WebSocket 接続の close コード は 1005 であるものと見なされる。 WebSocket 接続が close されて いて、かつ その端点で他に Close 制御フレームが受信されなかった場合(下層のトランスポート層の接続が失われた場合などに生じ得る)、 WebSocket 接続の close コード は 1006 であるものと見なされる。 As defined in Sections 5.5.1 and 7.4, a Close control frame may contain a status code indicating a reason for closure. A closing of the WebSocket connection may be initiated by either endpoint, potentially simultaneously. _The WebSocket Connection Close Code_ is defined as the status code (Section 7.4) contained in the first Close control frame received by the application implementing this protocol. If this Close control frame contains no status code, _The WebSocket Connection Close Code_ is considered to be 1005. If _The WebSocket Connection is Closed_ and no Close control frame was received by the endpoint (such as could occur if the underlying transport connection is lost), _The WebSocket Connection Close Code_ is considered to be 1006.

注記: 2つの端点において WebSocket 接続の close コード の値に一致を見ないことも起こり得る。 例えば,リモートの端点が Close フレームを送信したが、ローカルのアプリケーションは,まだそのソケットの受信バッファから Close フレームを含んでいるデータを読み取れてなく,かつ そのローカルのアプリケーションが独立に接続を close することにして Close フレームを送信した場合、いずれの端点も Close フレームを送信し, 受信し,それ以上 Close フレームを送信しないことになる。 それぞれの端点は相手の端点から送信されたステータスコードを WebSocket 接続の close コード として見ることになる。 そのため、両者の端点がほぼ同じ時刻に WebSocket closing ハンドシェイクの開始 を独立に行った場合、互いの WebSocket 接続の close コード の値が一致しないことが起こり得る。 NOTE: Two endpoints may not agree on the value of _The WebSocket Connection Close Code_. As an example, if the remote endpoint sent a Close frame but the local application has not yet read the data containing the Close frame from its socket's receive buffer, and the local application independently decided to close the connection and send a Close frame, both endpoints will have sent and received a Close frame and will not send further Close frames. Each endpoint will see the status code sent by the other end as _The WebSocket Connection Close Code_. As such, it is possible that the two endpoints may not agree on the value of _The WebSocket Connection Close Code_ in the case that both endpoints _Start the WebSocket Closing Handshake_ independently and at roughly the same time.

7.1.6. WebSocket 接続の close 事由

5.5.1 節, 7.4 節 にて定義されるように、 Close 制御フレームは、 closure の事由を指示するステータスコードに伴って, UTF-8 符号化されたデータも含み得る。 そのデータの解釈は端点に委ねられ,このプロトコルでは定義されない。 WebSocket 接続の closing は、同時刻の可能性も含め,いずれの端点からも起動され得る。 WebSocket 接続の close 事由 は、このプロトコルを実装するアプリケーションで受信された最初の Close 制御フレームに含められたステータスコード( 7.4 節 )に後続する, UTF-8 符号化データとして、定義される。 Close 制御フレームにその種のデータがない場合、 WebSocket 接続の close 事由 は空文字列である。 As defined in Sections 5.5.1 and 7.4, a Close control frame may contain a status code indicating a reason for closure, followed by UTF-8-encoded data, the interpretation of said data being left to the endpoints and not defined by this protocol. A closing of the WebSocket connection may be initiated by either endpoint, potentially simultaneously. _The WebSocket Connection Close Reason_ is defined as the UTF-8-encoded data following the status code (Section 7.4) contained in the first Close control frame received by the application implementing this protocol. If there is no such data in the Close control frame, _The WebSocket Connection Close Reason_ is the empty string.

注記: 7.1.5 節 と同じ論法により、2つの端点の WebSocket 接続の close 事由 に一致を見ないことも起こり得る。 NOTE: Following the same logic as noted in Section 7.1.5, two endpoints may not agree on _The WebSocket Connection Close Reason_.

7.1.7. WebSocket 接続を失敗させる

アルゴリズムと仕様の一部は、端点に対し, WebSocket 接続を失敗させる ことを要求する。 そのためには、クライアントは WebSocket 接続を close しなければならず,問題を適切な仕方により利用者に報告してもよい(とりわけ開発者に有用になるであろう)。 同様に、サーバは WebSocket 接続を close しなければならず,問題をログにとるべきである。 Certain algorithms and specifications require an endpoint to _Fail the WebSocket Connection_. To do so, the client MUST _Close the WebSocket Connection_, and MAY report the problem to the user (which would be especially useful for developers) in an appropriate manner. Similarly, to do so, the server MUST _Close the WebSocket Connection_, and SHOULD log the problem.

端点において WebSocket 接続を失敗させる ことが要求された時点に先立って, WebSocket 接続が確立されている 場合、端点は、 WebSocket 接続の close に移行する前に,適切なステータスコード( 7.4 節 )を伴う Close フレームを送信するべきである。 端点は、最初の段階で, WebSocket 接続を失敗させたエラーの性質から, 相手側が Close フレームの受信とその処理を行える見込みがないと判断したきは、 Close フレームの送信を省略してもよい。 端点は、 WebSocket 接続を失敗させる 指示を受けた後は,リモート端点からのデータの処理の試みを( Close フレームへの応答も含め)続行してはならない If _The WebSocket Connection is Established_ prior to the point where the endpoint is required to _Fail the WebSocket Connection_, the endpoint SHOULD send a Close frame with an appropriate status code (Section 7.4) before proceeding to _Close the WebSocket Connection_. An endpoint MAY omit sending a Close frame if it believes the other side is unlikely to be able to receive and process the Close frame, due to the nature of the error that led the WebSocket connection to fail in the first place. An endpoint MUST NOT continue to attempt to process data (including a responding Close frame) from the remote endpoint after being instructed to _Fail the WebSocket Connection_.

上に指示されたもの,および アプリケーション層(例えば, WebSocket API を利用するスクリプト)から指定されたときを除き、クライアントは接続を close するべきでない。 Except as indicated above or as specified by the application layer (e.g., a script using the WebSocket API), clients SHOULD NOT close the connection.

7.2. 異常な closure

7.2.1. クライアントから開始される closure

一部のアルゴリズムにおいては、特に opening ハンドシェイクの間に, WebSocket 接続を失敗させる ことが クライアントに要求される。 そのためには、クライアントは, 7.1.7 節 の定義に従って WebSocket 接続を失敗させ なければならない Certain algorithms, in particular during the opening handshake, require the client to _Fail the WebSocket Connection_. To do so, the client MUST _Fail the WebSocket Connection_ as defined in Section 7.1.7.

どの時点においても,下層のトランスポート層の接続が予期せず失われた場合、クライアントは WebSocket 接続を失敗させ なければならない If at any point the underlying transport layer connection is unexpectedly lost, the client MUST _Fail the WebSocket Connection_.

上に指示されたもの,および アプリケーション層(例えば, WebSocket API を利用するスクリプト)から指定されたときを除き、クライアントは接続を close するべきでない。 Except as indicated above or as specified by the application layer (e.g., a script using the WebSocket API), clients SHOULD NOT close the connection.

7.2.2. サーバから開始される closure

一部のアルゴリズムでは、 opening ハンドシェイクの間に,サーバに対し WebSocket 接続の中止 が要求または推奨される。 そのためには、サーバは単純に WebSocket 接続を close7.1.1 節 ) しなければならない Certain algorithms require or recommend that the server _Abort the WebSocket Connection_ during the opening handshake. To do so, the server MUST simply _Close the WebSocket Connection_ (Section 7.1.1).

7.2.3. 異常な closure からの復帰

異常な closure が起きる事由はいくつもある。 その種の closure が一時的なエラーによる場合、再接続により,良好な接続と通常の運用を回復し得る。 その種の closure が一時的でない問題に起因する場合もある。 その場合、広範のクライアントのそれぞれが異常な closure を経験していて,即時に, かつ継続的に再接続を試行した場合、サーバは多数のクライアントからの再接続の試行により, DoS 攻撃に相当する高負荷に晒され得る。 そのような展開による結果、適時にサービスを復帰できない, あるいは復帰がずっと困難なものになり得る。 Abnormal closures may be caused by any number of reasons. Such closures could be the result of a transient error, in which case reconnecting may lead to a good connection and a resumption of normal operations. Such closures may also be the result of a nontransient problem, in which case if each deployed client experiences an abnormal closure and immediately and persistently tries to reconnect, the server may experience what amounts to a denial-of-service attack by a large number of clients trying to reconnect. The end result of such a scenario could be that the service is unable to recover in a timely manner or recovery is made much more difficult.

これを防止するため、クライアントは、この節で述べたような異常な closure が起きた後に再接続を試行する際には,何らかの形のバックオフを利用するべきである。 To prevent this, clients SHOULD use some form of backoff when trying to reconnect after abnormal closures as described in this section.

最初の再接続の試みは、ランダムな時間だけ遅延されるべきである。 このランダムな遅延を選ぶためのパラメタの決定は、クライアントに委ねられる。 0 〜 5 秒までのランダムな値は、初期の遅延として適度なものである。 もっとも,クライアントは、実装の経験とアプリケーションの特性に基づいて,異なる間隔を遅延の長さに選択してもよい The first reconnect attempt SHOULD be delayed by a random amount of time. The parameters by which this random delay is chosen are left to the client to decide; a value chosen randomly between 0 and 5 seconds is a reasonable initial delay though clients MAY choose a different interval from which to select a delay length based on implementation experience and particular application.

最初の再接続の試みが失敗した場合、後続の再接続では,べき乗打切り待機法( truncated binary exponential backoff )などを用いて,遅延の間隔を漸増させるべきである。 Should the first reconnect attempt fail, subsequent reconnect attempts SHOULD be delayed by increasingly longer amounts of time, using a method such as truncated binary exponential backoff.

7.3. 接続の正常な closure

サーバは、必要に応じて, いつでも, WebSocket 接続を close してよい。 クライアントは WebSocket 接続を任意に close するべきでない。 いずれの場合も、端点は WebSocket closing ハンドシェイクの開始 手続き( 7.1.2 節 )へ移行して, closure に起動する。 Servers MAY close the WebSocket connection whenever desired. Clients SHOULD NOT close the WebSocket connection arbitrarily. In either case, an endpoint initiates a closure by following the procedures to _Start the WebSocket Closing Handshake_ (Section 7.1.2).

7.4. ステータスコード

すでに確立されている接続の closing に際しては(例えば, opening ハンドシェイクが完了した後に Close フレームを送信する際)、端点は closure の事由を指示してもよい。 端点によるこの事由の解釈,および 端点がこの事由に基づいてとるべき動作は、この仕様では定義されないままにされている。 この仕様は、一連の定義済みステータスコードを定義し,拡張, フレームワーク, アプリケーションが利用できる それらのコード範囲を指定する。 ステータスコード, および それに結び付けられるテキストのメッセージは、 Close フレームのオプションの成分である。 When closing an established connection (e.g., when sending a Close frame, after the opening handshake has completed), an endpoint MAY indicate a reason for closure. The interpretation of this reason by an endpoint, and the action an endpoint should take given this reason, are left undefined by this specification. This specification defines a set of pre-defined status codes and specifies which ranges may be used by extensions, frameworks, and end applications. The status code and any associated textual message are optional components of a Close frame.

7.4.1. 定義済みのステータスコード

端点は、 Close フレームを送信するときに,以下の定義済みのステータスコードを利用してよい Endpoints MAY use the following pre-defined status codes when sending a Close frame.

1000
1000 は、正常な closure を指示する。 確立された接続の目的が果たされたことを意味する。 1000 indicates a normal closure, meaning that the purpose for which the connection was established has been fulfilled.
1001
1001 は、端点が “消失” したことを指示する。 サーバがダウンしたり,ブラウザがページからどこか他へ遷移したときなど。 1001 indicates that an endpoint is "going away", such as a server going down or a browser having navigated away from a page.
1002
1002 は、端点がプロトコル­エラーにより接続を終了していることを指示する。 1002 indicates that an endpoint is terminating the connection due to a protocol error.
1003
1003 は、端点が受理できないデータを受信したなどの理由で,接続を終了していることを指示する(例えば,テキスト­データのみ解せる端点がバイナリ­メッセージを受信したとき、これを送信してもよい)。 1003 indicates that an endpoint is terminating the connection because it has received a type of data it cannot accept (e.g., an endpoint that understands only text data MAY send this if it receives a binary message).
1004
予約済み。 固有の意味は、将来に定義されることになるであろう。 Reserved. The specific meaning might be defined in the future.
1005
1005 は、予約済みの値であり,端点により Close 制御フレームのステータスコードに設定されてはならない。 これは、どのステータスコードも実際には供されていないことを指示するステータスコードを必要とするアプリケーションのためのものとして,指定を受けている。 1005 is a reserved value and MUST NOT be set as a status code in a Close control frame by an endpoint. It is designated for use in applications expecting a status code to indicate that no status code was actually present.
1006
1006 は、予約済みの値であり,端点により Close 制御フレームのステータスコードに設定されてはならない。 これは、接続が異常に(例えば, Close 制御フレームの送信や受信­抜きに) close されたことを指示するステータスコードを必要とするアプリケーションのためのものとして,指定を受けている。 1006 is a reserved value and MUST NOT be set as a status code in a Close control frame by an endpoint. It is designated for use in applications expecting a status code to indicate that the connection was closed abnormally, e.g., without sending or receiving a Close control frame.
1007
1007 は、受信したメッセージ内のデータがメッセージの種別と整合していない理由で,端点が接続を終了していることを指示する (例えば,テキスト­メッセージ内の非 UTF-8 [RFC3629] )。 1007 indicates that an endpoint is terminating the connection because it has received data within a message that was not consistent with the type of the message (e.g., non-UTF-8 [RFC3629] data within a text message).
1008
1008 は、ポリシーに違反しているメッセージを受信した理由で,端点が接続を終了していることを指示する。 これは、より相応しいステータスコード(例えば, 1003 や 1009 )が他にないとき, または ポリシーについての固有の詳細を隠す必要があるときに返し得る,汎用のステータスコードである。 1008 indicates that an endpoint is terminating the connection because it has received a message that violates its policy. This is a generic status code that can be returned when there is no other more suitable status code (e.g., 1003 or 1009) or if there is a need to hide specific details about the policy.
1009
1009 は、端点が処理するには大き過ぎるメッセージを受信した理由で,接続を終了していることを指示する。 1009 indicates that an endpoint is terminating the connection because it has received a message that is too big for it to process.
1010
1010 は、一つ以上の拡張が折衝されることが予期されているのに,サーバが WebSocket ハンドシェイクの応答メッセージの中にそれらを返さなかった理由で,端点(クライアント)が接続を終了していることを指示する。 Close フレームの reason 部には、必要な拡張のリストが出現するべきである。 サーバは、代わりに WebSocket ハンドシェイクを失敗させられるので,このステータスコードを利用することはないことに注意。 1010 indicates that an endpoint (client) is terminating the connection because it has expected the server to negotiate one or more extension, but the server didn't return them in the response message of the WebSocket handshake. The list of extensions that are needed SHOULD appear in the /reason/ part of the Close frame. Note that this status code is not used by the server, because it can fail the WebSocket handshake instead.
1011
1011 は、サーバがリクエストを果たせないような,予期しない状況に遭遇した理由で、接続を終了していることを指示する。 正誤表による修正提案( Held for Document Update )あり: “サーバ” → “端点” 】 1011 indicates that a server is terminating the connection because it encountered an unexpected condition that prevented it from fulfilling the request.
1015
1015 は、予約済みの値であり,端点により Close 制御フレームのステータスコードに設定されてはならない。 これは、TLS ハンドシェイクを行った際の失敗により(例えば,サーバが証明書を検証できないなど),接続が close されたことを指示するステータスコードを必要とするアプリケーションのためのものとして,指定を受けている。 1015 is a reserved value and MUST NOT be set as a status code in a Close control frame by an endpoint. It is designated for use in applications expecting a status code to indicate that the connection was closed due to a failure to perform a TLS handshake (e.g., the server certificate can't be verified).

7.4.2. 予約済みステータスコードの範囲

0-999
範囲 0-999 のステータスコードは、利用されない。 Status codes in the range 0-999 are not used.
1000-2999
範囲 1000-2999 のステータスコードは、このプロトコルとその将来の改訂版, および 恒久的で容易に可用な 公開の仕様で指定される拡張による定義のために,予約済みである。 Status codes in the range 1000-2999 are reserved for definition by this protocol, its future revisions, and extensions specified in a permanent and readily available public specification.
3000-3999
範囲 3000-3999 のステータスコードは、ライブラリ, フレームワーク, アプリケーション 利用のために,予約済みである。 これらのステータスコード は、 IANA により直接的に登録される。 これらのコードの解釈は、このプロトコルでは未定義である。 Status codes in the range 3000-3999 are reserved for use by libraries, frameworks, and applications. These status codes are registered directly with IANA. The interpretation of these codes is undefined by this protocol.
4000-4999
範囲 4000-4999 のステータスコードは、私的利用のために予約済みなので,登録できない。 これらのコードは WebSocket アプリケーションとの事前の取り決めにより利用できる。 これらのコードの解釈は、このプロトコルでは定義されない。 Status codes in the range 4000-4999 are reserved for private use and thus can't be registered. Such codes can be used by prior agreements between WebSocket applications. The interpretation of these codes is undefined by this protocol.

8. エラーの取り扱い

8.1. UTF-8 符号化データにおけるエラーの取り扱い

端点がバイト­ストリームを UTF-8 として解釈する際に,そのバイト­ストリームが実際には妥当な UTF-8 ストリームではなかった場合、その端点は WebSocket 接続を失敗させ なければならない。 この規則は、 opening ハンドシェイクの間にも, 後続のデータ交換の間にも,いずれにも適用される。 When an endpoint is to interpret a byte stream as UTF-8 but finds that the byte stream is not, in fact, a valid UTF-8 stream, that endpoint MUST _Fail the WebSocket Connection_. This rule applies both during the opening handshake and during subsequent data exchange.

9. 拡張

WebSocket クライアントは、この仕様の拡張をリクエストしてもよい。 WebSocket サーバは、クライアントからリクエストされた拡張の一部またはすべてを 受理してよい。 サーバは、クライアントからリクエストされていない拡張を応答してはならない。 クライアント↔サーバ間の折衝の中に,拡張のパラメタが内包される場合、これらのパラメタは,パラメタを適用する拡張の仕様に則って選ばれなければならない WebSocket clients MAY request extensions to this specification, and WebSocket servers MAY accept some or all extensions requested by the client. A server MUST NOT respond with any extension not requested by the client. If extension parameters are included in negotiations between the client and the server, those parameters MUST be chosen in accordance with the specification of the extension to which the parameters apply.

9.1. 拡張の折衝処理

クライアントは、HTTP ヘッダの通常の規則( [RFC2616] 4.2 節 参照)に従って, Sec-WebSocket-Extensions ヘッダを内包することにより、拡張をリクエストする。 ヘッダの値は,次の ABNF [RFC2616] にて定義される。 この節では “暗黙の *LWS 規則” も内包する, [RFC2616] による ABNF 構文/規則が用いられることに注意。 折衝の間に,下記 ABNF に適合しない値がクライアントまたはサーバで受信された場合、そのような不正な形式のデータを受信した側は即時に WebSocket 接続を失敗させ なければならない A client requests extensions by including a |Sec-WebSocket-Extensions| header field, which follows the normal rules for HTTP header fields (see [RFC2616], Section 4.2) and the value of the header field is defined by the following ABNF [RFC2616]. Note that this section is using ABNF syntax/rules from [RFC2616], including the "implied *LWS rule". If a value is received by either the client or the server during negotiation that does not conform to the ABNF below, the recipient of such malformed data MUST immediately _Fail the WebSocket Connection_.

Sec-WebSocket-Extensions = extension-list
extension-list = 1#extension
extension = extension-token *( ";" extension-param )
extension-token = registered-token
registered-token = token
extension-param = token [ "=" (token | quoted-string) ]
    ; quoted-string 構文を利用する場合、
    ; quoted-string エスケープ復元後の値は
    ; 'token' ABNF に適合しなければならない

他の HTTP ヘッダと同様、このヘッダは,複数行に渡って,分割されたり結合されてもよいことに注意。 よって,次は: Note that like other HTTP header fields, this header field MAY be split or combined across multiple lines. Ergo, the following are equivalent:

Sec-WebSocket-Extensions: foo
Sec-WebSocket-Extensions: bar; baz=2

正確に次と等価である: is exactly equivalent to

Sec-WebSocket-Extensions: foo, bar; baz=2

利用されるどの拡張トークンも,登録済みのトークンでなければならない11.4 節 を見よ)。 与えられた拡張に伴なって供されるパラメタは、その拡張のために定義されたものでなければならない。 クライアントは,告知された拡張を申し入れるのみであり、サーバがその拡張の利用を指示しない限り,それらを利用してはならないことに注意。 Any extension-token used MUST be a registered token (see Section 11.4). The parameters supplied with any given extension MUST be defined for that extension. Note that the client is only offering to use any advertised extensions and MUST NOT use them unless the server indicates that it wishes to use the extension.

拡張の順序は有意であることに注意。 複数の拡張­間のやりとりが拡張を定義する文書において定義されてもよい。 そのような定義がない場合、クライアントのリクエストにリストされたヘッダの順序は,最初のオプションを最高位として,クライアントが利用を希望する順序を表現しているものと解釈する。 サーバの応答にリストされる拡張は、接続に実際に利用される拡張を表現する。 もし,拡張がデータやフレーミングに手を加えることがある場合、データに対する操作の順序は、 opening ハンドシェイクにおけるサーバの応答にリストされた拡張の順序と同じであるものと見なされるべきである。 Note that the order of extensions is significant. Any interactions between multiple extensions MAY be defined in the documents defining the extensions. In the absence of such definitions, the interpretation is that the header fields listed by the client in its request represent a preference of the header fields it wishes to use, with the first options listed being most preferable. The extensions listed by the server in response represent the extensions actually in use for the connection. Should the extensions modify the data and/or framing, the order of operations on the data should be assumed to be the same as the order in which the extensions are listed in the server's response in the opening handshake.

例えば,2つの拡張 "foo" と "bar" があって,サーバから送信された Sec-WebSocket-Extensions ヘッダが値 "foo, bar" を持つ場合、データに対する操作は、foo を作用させた後に bar を作用させる形に,データ自身に対する変更(圧縮など)やフレーミングに対する変更は、 “スタック” され得る。 For example, if there are two extensions "foo" and "bar" and if the header field |Sec-WebSocket-Extensions| sent by the server has the value "foo, bar", then operations on the data will be made as bar(foo(data)), be those changes to the data itself (such as compression) or changes to the framing that may "stack".

受理­可能な拡張のヘッダの例(読み易くするため,長い行は折り返されている): Non-normative examples of acceptable extension header fields (note that long lines are folded for readability):

Sec-WebSocket-Extensions: deflate-stream
Sec-WebSocket-Extensions: mux; max-channels=4; flow-control,
deflate-stream
Sec-WebSocket-Extensions: private-extension

サーバは、クライアントからリクエストされた1個以上の拡張を Sec-WebSocket-Extensions ヘッダに内包することにより,受理する。 拡張パラメタの解釈、およびクライアントからリクエストされたパラメタの集合に対し,サーバから妥当な応答を構成するための要素については、それらの拡張が個別に定義することになる。 A server accepts one or more extensions by including a |Sec-WebSocket-Extensions| header field containing one or more extensions that were requested by the client. The interpretation of any extension parameters, and what constitutes a valid response by a server to a requested set of parameters by a client, will be defined by each such extension.

9.2. 既知の拡張

拡張は、実装が追加のプロトコル特色機能をオプトインするための仕組みを提供する。 この文書は いかなる拡張も定義しないが、実装は別々に定義された拡張を利用してよい Extensions provide a mechanism for implementations to opt-in to additional protocol features. This document doesn't define any extension, but implementations MAY use extensions defined separately.

10. セキュリティ上の考慮点

この節では、WebSocket Protocol に適用され得る,いくつかのセキュリティ上の考慮点について述べる。 固有のセキュリティ上の考慮点は、この節の下位節にて述べられる。 This section describes some security considerations applicable to the WebSocket Protocol. Specific security considerations are described in subsections of this section.

10.1. 非ブラウザ クライアント

WebSocket Protocol は、ウェブ­ブラウザなどの信頼できるアプリケーションの内部で実行されている悪意のある JavaScript から保護する。 例えば, Origin ヘッダの検査(下を見よ)など。 追加の詳細は 1.6 節 を見よ。 そのような前提は、より capable なクライアントの場合には成立しない。 The WebSocket Protocol protects against malicious JavaScript running inside a trusted application such as a web browser, for example, by checking of the |Origin| header field (see below). See Section 1.6 for additional details. Such assumptions don't hold true in the case of a more-capable client.

このプロトコルは、ウェブ­ページ内のスクリプトからの利用が想定されているが、ホストから直接的にも利用できる。 そのようなホストは自身に利するようにふるまうので、サーバを誤誘導するように偽装された Origin ヘッダも送信し得る。 したがって、サーバは,既知の生成元からのスクリプトと直接的にやりとりしていると見なすことには慎重になるべきで、予期されない方法でアクセスされている可能性を考慮しなければならない。 特に、サーバは,どの入力も妥当であるものと信用すべきではない。 While this protocol is intended to be used by scripts in web pages, it can also be used directly by hosts. Such hosts are acting on their own behalf and can therefore send fake |Origin| header fields, misleading the server. Servers should therefore be careful about assuming that they are talking directly to scripts from known origins and must consider that they might be accessed in unexpected ways. In particular, a server should not trust that any input is valid.

例: サーバは、入力を SQL クエリの一部に利用する際に,自身が SQL インジェクションの感染源にならないように、すべての入力テキストを SQL サーバに渡す前にエスケープすべきである。 EXAMPLE: If the server uses input as part of SQL queries, all input text should be escaped before being passed to the SQL server, lest the server be susceptible to SQL injection.

10.2. 生成元についての考慮点

任意のウェブ­ページでなく,一定のサイトのみに属するウェブ­ページからの入力を処理することが想定されているサーバは、 Origin ヘッダの値が予期されている生成元であるかどうか,検証するべきである。 生成元がサーバにとって受理できない場合、 HTTP 403 Forbidden ステータスコード を含ませた返信により, WebSocket ハンドシェイクに応答するべきである。 Servers that are not intended to process input from any web page but only for certain sites SHOULD verify the |Origin| field is an origin they expect. If the origin indicated is unacceptable to the server, then it SHOULD respond to the WebSocket handshake with a reply containing HTTP 403 Forbidden status code.

Origin ヘッダは、概して,信頼できるクライアントの文脈の下で実行されている JavaScript アプリケーションの作者が 信頼できない主体であるときの 攻撃­事例からの保護を供する。 クライアント自身は、サーバと接触することができ, Origin ヘッダの仕組みにより,その種の通信­特権を JavaScript アプリケーションにまで広げるかどうかを決定する。 その意図は、非ブラウザによる接続の確立を防止するのではなく、信頼できるブラウザが潜在的に悪意のある JavaScript の制御下にあっても, WebSocket ハンドシェイクを偽装できなくする所にある。 The |Origin| header field protects from the attack cases when the untrusted party is typically the author of a JavaScript application that is executing in the context of the trusted client. The client itself can contact the server and, via the mechanism of the |Origin| header field, determine whether to extend those communication privileges to the JavaScript application. The intent is not to prevent non-browsers from establishing connections but rather to ensure that trusted browsers under the control of potentially malicious JavaScript cannot fake a WebSocket handshake.

10.3. 通信基盤に対する攻撃(マスクの適用)

端点が WebSocket 経由による攻撃の標的になることに加えて、プロキシなどの,ウェブ通信基盤の他の部分も攻撃の対象になり得る。 In addition to endpoints being the target of attacks via WebSockets, other parts of web infrastructure, such as proxies, may be the subject of an attack.

このプロトコルが開発されていくに伴い、実ネットに配備されている caching プロキシを汚染に導くような,プロキシに対する攻撃のクラスを実証する実験が実施された [TALKING] 。 攻撃の一般的な手口は、 “攻撃者の” 制御下にあるサーバへの接続を確立させ、 WebSocket Protocol による接続の確立を真似るように HTTP 接続­上で UPGRADE を行い、その UPGRADE された接続を通して,特定の既知のリソースに対する GET リクエストに似せるように(攻撃の中では、ごくありふれた,広告配信ネットワーク上のアクセス記録やリソースのためのスクリプトに似た何か),後続してデータを送信するものであった。 リモートのサーバは、偽装された GET リクエストに対する応答に似た何かで応答することになるであろう。 この応答がゼロでない割合の中継点にキャッシュされることにより,キャッシュが汚染される。 この攻撃による結果、利用者が攻撃者の制御下のウェブ­サイトを気付かずに訪問したとするとき、攻撃者はその利用者のキャッシュや同じキャッシュを共有する他の利用者のそれを汚染することにより,他の生成元に属する悪意のあるスクリプトを実行させられる可能性が生じ、ウェブのセキュリティ­モデルが危うくされる。 As this protocol was being developed, an experiment was conducted to demonstrate a class of attacks on proxies that led to the poisoning of caching proxies deployed in the wild [TALKING]. The general form of the attack was to establish a connection to a server under the "attacker's" control, perform an UPGRADE on the HTTP connection similar to what the WebSocket Protocol does to establish a connection, and subsequently send data over that UPGRADEd connection that looked like a GET request for a specific known resource (which in an attack would likely be something like a widely deployed script for tracking hits or a resource on an ad-serving network). The remote server would respond with something that looked like a response to the fake GET request, and this response would be cached by a nonzero percentage of deployed intermediaries, thus poisoning the cache. The net effect of this attack would be that if a user could be convinced to visit a website the attacker controlled, the attacker could potentially poison the cache for that user and other users behind the same cache and run malicious script on other origins, compromising the web security model.

中継点に対するその種の攻撃を回避するためには、アプリケーションから供されたデータに HTTP に準じないフレーミングを施すだけでは十分でない。 それぞれの非準拠の中継点が、そのような非 HTTP フレーミングを素通りさせずに,フレーム­ペイロードに対し不正に動作しているかどうかを、包括的に検出したり試験することは不可能なので。 したがって,防御策として、クライアントからサーバへのデータすべてにマスクをかけることにより,リモートのスクリプト(攻撃者)が 伝送路に出現するデータがどのように送信されるか を制御できなくし、中継点から誤って HTTP リクエストに解釈され得るようなメッセージは構築できないようにされている。 To avoid such attacks on deployed intermediaries, it is not sufficient to prefix application-supplied data with framing that is not compliant with HTTP, as it is not possible to exhaustively discover and test that each nonconformant intermediary does not skip such non-HTTP framing and act incorrectly on the frame payload. Thus, the defense adopted is to mask all data from the client to the server, so that the remote script (attacker) does not have control over how the data being sent appears on the wire and thus cannot construct a message that could be misinterpreted by an intermediary as an HTTP request.

クライアントは、データを提供する末端アプリケーションからは予測できないようなアルゴリズムを用いて,各フレームごとに新たなマスキングキーを選ばなければならない。 例えば、各マスキングキーを暗号論的に強い乱数生成器から取り出すなど。 同じキーが用いられたり,次のキーがどのように選ばれるかについて解読可能なパターンが存在する場合、攻撃者はマスクされた際に HTTP リクエストに見え得るメッセージを送信­可能になる(攻撃者が伝送路­上の目的のメッセージを取得して,次に用いられるマスキングキーによりマスクを施せば、クライアントがマスキングキーを適用したときに,データのマスクは実質的に解除されることになる。) Clients MUST choose a new masking key for each frame, using an algorithm that cannot be predicted by end applications that provide data. For example, each masking could be drawn from a cryptographically strong random number generator. If the same key is used or a decipherable pattern exists for how the next key is chosen, the attacker can send a message that, when masked, could appear to be an HTTP request (by taking the message the attacker wishes to see on the wire and masking it with the next masking key to be used, the masking key will effectively unmask the data when the client applies it).

ひとたびクライアントからフレームの伝送が始まったなら、そのフレームのペイロード(アプリケーションから供されたデータ)は,アプリケーションから手を加えられないようにする必要がある。 さもなくば,攻撃者は、長いフレームを送信して,初期データが既知の値である所から(例えばすべてゼロ),データの最初の部分を受領した際に利用されているマスキングキーを算出し、フレーム内のまだ送信されていないデータに対し,マスクされた際に HTTP リクエストに見えるように手を加えることが可能になる(これは前段落で述べた、既知の, または予測可能なマスキングキーを用いたときの問題と本質的に同じである)。 追加のデータが送信されたり, 送信されつつあるデータが何らかの方法で変更された場合、その新たな/変更されたデータは,新たなフレーム内で, したがって新たなマスキングキーにより,送信されなければならない。 手短かに言えば、フレームの伝送が始まった時点から,その内容にリモートのスクリプト(アプリケーション)から手が加えられるようになってはならない。 It is also necessary that once the transmission of a frame from a client has begun, the payload (application-supplied data) of that frame must not be capable of being modified by the application. Otherwise, an attacker could send a long frame where the initial data was a known value (such as all zeros), compute the masking key being used upon receipt of the first part of the data, and then modify the data that is yet to be sent in the frame to appear as an HTTP request when masked. (This is essentially the same problem described in the previous paragraph with using a known or predictable masking key.) If additional data is to be sent or data to be sent is somehow changed, that new or changed data must be sent in a new frame and thus with a new masking key. In short, once transmission of a frame begins, the contents must not be modifiable by the remote script (application).

対抗して保護すべき脅威モデルは、クライアントが送信するデータが HTTP リクエストとして現れることである。 したがって、マスクされる必要のあるチャンネルは,クライアントからサーバへのデータになる。 サーバからクライアントへのデータは,応答に似せ得るが、そのためにはクライアントもリクエストを偽造できなければならない。 そのような理由から、両方向ともデータをマスクする必要があるとは考えられていない(サーバからクライアントへのデータはマスクされない)。 The threat model being protected against is one in which the client sends data that appears to be an HTTP request. As such, the channel that needs to be masked is the data from the client to the server. The data from the server to the client can be made to look like a response, but to accomplish this request, the client must also be able to forge a request. As such, it was not deemed necessary to mask data in both directions (the data from the server to the client is not masked).

マスクの適用により提供される保護にも関わらず,非準拠の HTTP プロキシは、依然として,マスクを適用しないクライアントとサーバによる,この種の攻撃からの汚染に脆弱性があることになる。 Despite the protection provided by masking, non-compliant HTTP proxies will still be vulnerable to poisoning attacks of this type by clients and servers that do not apply masking.

10.4. 実装ごとに固有の制限

複数フレームからの再構築­後のフレーム­サイズまたは総メッセージ­サイズに対し,自身に, あるいはプラットフォームごとに固有の制限がある実装は、これらの制限の超過から自身を保護しなければならない。 (例えば,悪意のある端点は、単独の巨大フレーム(例えば,サイズが 2 の 60 乗)を送信したり, 断片化されたメッセージの一部をなす 小フレームの長大なストリームを送信することにより,そのピアの記憶域の枯渇や DoS 攻撃を仕掛け得る。) そのような実装は、フレーム­サイズ, および複数フレームからの再構築­後の総メッセージ­サイズに制限を課するべきである。 Implementations that have implementation- and/or platform-specific limitations regarding the frame size or total message size after reassembly from multiple frames MUST protect themselves against exceeding those limits. (For example, a malicious endpoint can try to exhaust its peer's memory or mount a denial-of-service attack by sending either a single big frame (e.g., of size 2**60) or by sending a long stream of small frames that are a part of a fragmented message.) Such an implementation SHOULD impose a limit on frame sizes and the total message size after reassembly from multiple frames.

10.5. WebSocket クライアント認証

このプロトコルは、 WebSocket ハンドシェイクの間にサーバがクライアントを認証できるような,特定の方法は規定しない。 WebSocket サーバは、クッキー, HTTP 認証, TLS 認証など,汎用 HTTP サーバにて可用な,任意のクライアント認証の仕組みを利用できる。 This protocol doesn't prescribe any particular way that servers can authenticate clients during the WebSocket handshake. The WebSocket server can use any client authentication mechanism available to a generic HTTP server, such as cookies, HTTP authentication, or TLS authentication.

10.6. 接続の機密性と完全性

接続の機密性と完全性は、WebSocket Protocol を TLS ( wss URI )を通して実行することにより提供される。 WebSocket の実装は、 TLS をサポートしなければならず,それらのピアと通信するときは使用するべきである。 Connection confidentiality and integrity is provided by running the WebSocket Protocol over TLS (wss URIs). WebSocket implementations MUST support TLS and SHOULD employ it when communicating with their peers.

TLS を利用する接続において TLS が提供する利点の大きさは、TLS ハンドシェイクの間に折衝されるアルゴリズムの強度に大きく依存する。 例えば、一部の TLS 暗号の仕組みは接続の機密性を提供しない。 適度なレベルの保護を達成するためには,クライアントは、 Strong TLS アルゴリズムのみを利用するべきである。 "Web Security Context:User Interface Guidelines" [W3C.REC-wsc-ui-20100812] に, Strong TLS アルゴリズムを構成する要素について論じられている。 [RFC5246]Appendix A.5Appendix D.3 にて、追加の手引きを見られる。 For connections using TLS, the amount of benefit provided by TLS depends greatly on the strength of the algorithms negotiated during the TLS handshake. For example, some TLS cipher mechanisms don't provide connection confidentiality. To achieve reasonable levels of protection, clients should use only Strong TLS algorithms. "Web Security Context: User Interface Guidelines" [W3C.REC-wsc-ui-20100812] discusses what constitutes Strong TLS algorithms. [RFC5246] provides additional guidance in Appendix A.5 and Appendix D.3.

10.7. 妥当でないデータの取り扱い

着信データの妥当­性は、クライアント, サーバの両者において検証されなければならない。 どの時点であれ、端点は、妥当でないデータ — 自身が解し得ない, または 入力の安全性を決定するにあたって何らかの基準に違反しているデータ, あるいは予期される値に対応しない opening ハンドシェイク(例えば,クライアントのリクエスト内の不正な path や生成元) — に直面した場合には, TCP 接続を落としてもよい。 妥当でないデータが WebSocket ハンドシェイクの成功後に受信された場合、端点は、 WebSocket 接続の close に移行する前に,適切なステータスコードを伴う Close フレームを( 7.4 節 )送信するべきである。 適切なステータスコードを伴う Close フレームの利用は、問題の診断を支援する。 妥当でないデータが WebSocket ハンドシェイクの間に送信されてきた場合、サーバは適切な HTTP [RFC2616] ステータスコードを返すべきである。 Incoming data MUST always be validated by both clients and servers. If, at any time, an endpoint is faced with data that it does not understand or that violates some criteria by which the endpoint determines safety of input, or when the endpoint sees an opening handshake that does not correspond to the values it is expecting (e.g., incorrect path or origin in the client request), the endpoint MAY drop the TCP connection. If the invalid data was received after a successful WebSocket handshake, the endpoint SHOULD send a Close frame with an appropriate status code (Section 7.4) before proceeding to _Close the WebSocket Connection_. Use of a Close frame with an appropriate status code can help in diagnosing the problem. If the invalid data is sent during the WebSocket handshake, the server SHOULD return an appropriate HTTP [RFC2616] status code.

誤った符号化方式を用いたテキスト­データの送信から生じる,共通的なセキュリティ問題のクラスがある。 このプロトコルは、種別 Text のメッセージは,( Binary 他の種別とは対照的に) UTF-8 符号化データを含むものと指定している。 長さも依然として指示されており、このプロトコルを実装するアプリケーションは,フレームが実際に終端する所を決定する際に 長さを利用すべきであるが、不適切な符号化方式によるデータの送信は,依然として,このプロトコル上に構築されたアプリケーションの前提を覆し得るものであり、データの誤解釈による,データの喪失や潜在的セキュリティ­バグを導き得る。 A common class of security problems arises when sending text data using the wrong encoding. This protocol specifies that messages with a Text data type (as opposed to Binary or other types) contain UTF-8-encoded data. Although the length is still indicated and applications implementing this protocol should use the length to determine where the frame actually ends, sending data in an improper encoding may still break assumptions that applications built on top of this protocol may make, leading to anything from misinterpretation of data to loss of data or potential security bugs.

10.8. WebSocket ハンドシェイクによる SHA-1 の利用

この文書で述べられた WebSocket ハンドシェイクは、衝突耐性や第二原像攻撃 参考 に対する耐性など,いかなる SHA-1 のプロパティにも依存しない( [RFC4270] に述べられるように)。 The WebSocket handshake described in this document doesn't depend on any security properties of SHA-1, such as collision resistance or resistance to the second pre-image attack (as described in [RFC4270]).

11. IANA Considerations

11.1. 新たな URI スキームの登録

11.1.1. "ws" スキームの登録

ws URI は、 WebSocket サーバとリソース名を識別する。 A |ws| URI identifies a WebSocket server and resource name.

URI スキーム名
ws
位置付け
恒久的 Permanent
URI スキーム構文

ABNF [RFC5234] 構文および URI 仕様 [RFC3986] の ABNF の終端記号を用いて: Using the ABNF [RFC5234] syntax and ABNF terminals from the URI specification [RFC3986]:

"ws:" "//" authority path-abempty [ "?" query ]

path-abemptyquery [RFC3986] 成分は、要望されたサービスの種類を識別するために,サーバへ送信されるリソース名を形成する。 他の成分は、 [RFC3986] に述べられる意味を持つ。 The <path-abempty> and <query> [RFC3986] components form the resource name sent to the server to identify the kind of service desired. Other components have the meanings described in [RFC3986].

URI スキーム意味論
このスキームのための唯一の運用は、 WebSocket Protocol を利用して接続を open することである。 The only operation for this scheme is to open a connection using the WebSocket Protocol.
符号化方式についての考慮点
上で定義された構文から除外されたホスト成分­内の文字は、 [RFC3987] またはその後継文書の指定に従って, Unicode から ASCII に変換されなければならない。 スキームに基づく正規化の目的においては、ホスト成分の Internationalized Domain Name ( IDN )形式とそれらの punycode への変換は,等価なものと見なされる( [RFC3987] 5.3.3 節 参照)。 Characters in the host component that are excluded by the syntax defined above MUST be converted from Unicode to ASCII as specified in [RFC3987] or its replacement. For the purposes of scheme-based normalization, Internationalized Domain Name (IDN) forms of the host component and their conversions to punycode are considered equivalent (see Section 5.3.3 of [RFC3987]).
上で定義された構文から除外された,他の成分­内の文字は、まず, UTF-8 に符号化した上で,結果のバイト並びを[ URI [RFC3986], IRI (国際化リソース識別子) [RFC3987] ]仕様の定義に従って,パーセント符号化形に置換することにより、 Unicode から ASCII へ変換されなければならない Characters in other components that are excluded by the syntax defined above MUST be converted from Unicode to ASCII by first encoding the characters as UTF-8 and then replacing the corresponding bytes using their percent-encoded form as defined in the URI [RFC3986] and Internationalized Resource Identifier (IRI) [RFC3987] specifications.
この URI スキーム名を利用するアプリケーション/プロトコル
WebSocket Protocol
相互運用性についての考慮点
WebSocket の利用は HTTP バージョン 1.1 以上の利用を要求する。 Use of WebSocket requires use of HTTP version 1.1 or higher.
セキュリティ上の考慮点
セキュリティ上の考慮点” 節を見よ。 See "Security Considerations" section.
連絡先
HYBI WG <hybi@ietf.org>
作成/変更管理
IETF <iesg@ietf.org>
参照
RFC 6455

11.1.2. "wss" スキームの登録

wss URI は、 WebSocket サーバとリソース名を識別し,その接続を通るトラフィックが TLS により保護されることになることを指示する(データの機密性と完全性および端点の認証などの, TLS の標準的な利点も含め)。 A |wss| URI identifies a WebSocket server and resource name and indicates that traffic over that connection is to be protected via TLS (including standard benefits of TLS such as data confidentiality and integrity and endpoint authentication).

URI スキーム名
wss
位置付け
恒久的 Permanent
URI スキーム構文

ABNF [RFC5234] 構文および URI 仕様 [RFC3986] の ABNF の終端記号を用いて: Using the ABNF [RFC5234] syntax and ABNF terminals from the URI specification [RFC3986]:

"wss:" "//" authority path-abempty [ "?" query ]

path-abemptyquery 成分は、要望されたサービスの種類を識別するために,サーバへ送信されるリソース名を形成する。 他の成分は、 [RFC3986] に述べられる意味を持つ。 The <path-abempty> and <query> components form the resource name sent to the server to identify the kind of service desired. Other components have the meanings described in [RFC3986].

URI スキーム意味論
このスキームのための唯一の運用は、 WebSocket Protocol を利用して, TLS により暗号化された接続を open することである。 The only operation for this scheme is to open a connection using the WebSocket Protocol, encrypted using TLS.
符号化方式についての考慮点
上で定義された構文から除外されたホスト成分­内の文字は、 [RFC3987] またはその後継文書の指定に従って, Unicode から ASCII へ変換されなければならない。 スキームに基づく正規化の目的においては、 IDN 形式によるホスト成分と, それをピュニコード 【 punycode — 参考 へ変換したものとは,等価なものと見なされる( [RFC3987] 5.3.3 節 参照)。 Characters in the host component that are excluded by the syntax defined above MUST be converted from Unicode to ASCII as specified in [RFC3987] or its replacement. For the purposes of scheme-based normalization IDN forms of the host component and their conversions to punycode are considered equivalent (see Section 5.3.3 of [RFC3987]).
上で定義された構文から除外された,他の成分­内の文字は、まず, UTF-8 に符号化した上で,結果のバイト並びを[ URI [RFC3986], IRI [RFC3987] ]仕様の定義に従って,パーセント符号化形に置換することにより、 Unicode から ASCII へ変換されなければならない Characters in other components that are excluded by the syntax defined above MUST be converted from Unicode to ASCII by first encoding the characters as UTF-8 and then replacing the corresponding bytes using their percent-encoded form as defined in the URI [RFC3986] and IRI [RFC3987] specifications.
この URI スキーム名を利用するアプリケーション/プロトコル
TLS を通した WebSocket Protocol WebSocket Protocol over TLS
相互運用性についての考慮点
WebSocket の利用は HTTP バージョン 1.1 以上の利用を要求する。 Use of WebSocket requires use of HTTP version 1.1 or higher.
セキュリティ上の考慮点
セキュリティ上の考慮点” 節を見よ。 See "Security Considerations" section.
連絡先
HYBI WG <hybi@ietf.org>
作成/変更管理
IETF <iesg@ietf.org>
参照
RFC 6455

11.2. "WebSocket" HTTP Upgrade キーワードの登録

この節では、 [RFC2817] に従って, HTTP Upgrade Tokens Registry に登録されたキーワードを定義する。 This section defines a keyword registered in the HTTP Upgrade Tokens Registry as per RFC 2817 [RFC2817].

トークンの名前
WebSocket
作成/変更管理
IETF <iesg@ietf.org>
連絡先
HYBI <hybi@ietf.org>
参照
RFC 6455

11.3. 新たな HTTP ヘッダの登録

11.3.1. Sec-WebSocket-Key

この節では、 Permanent Message Header Field Names レジストリ [RFC3864] に登録されたヘッダを述べる。 This section describes a header field registered in the Permanent Message Header Field Names registry [RFC3864].

ヘッダ名
Sec-WebSocket-Key
適用可能なプロトコル
http
位置付け
標準 standard
作成/変更管理
IETF
仕様­文書
RFC 6455
関連情報
このヘッダは WebSocket opening ハンドシェイクにおいてのみ利用される。 This header field is only used for WebSocket opening handshake.

Sec-WebSocket-Key ヘッダは WebSocket opening ハンドシェイクの中で利用される。 これは、サーバが妥当な WebSocket opening ハンドシェイクを受信したことを立証するための一環として,クライアントからサーバへ送信されるものであり、サーバが利用する情報の一部を供する。 これは、 "疑わない" ( unsuspecting ) WebSocket サーバへ向けてデータ送信を濫用する非 WebSocket クライアント(例えば, HTTP クライアント)からの接続を,サーバが受理しないようにすることを支援する。 The |Sec-WebSocket-Key| header field is used in the WebSocket opening handshake. It is sent from the client to the server to provide part of the information used by the server to prove that it received a valid WebSocket opening handshake. This helps ensure that the server does not accept connections from non-WebSocket clients (e.g., HTTP clients) that are being abused to send data to unsuspecting WebSocket servers.

Sec-WebSocket-Key ヘッダは、一個の HTTP リクエストの中に複数回出現してはならない The |Sec-WebSocket-Key| header field MUST NOT appear more than once in an HTTP request.

11.3.2. Sec-WebSocket-Extensions

この節では、 Permanent Message Header Field Names レジストリ [RFC3864] に登録されたヘッダを述べる。 This section describes a header field for registration in the Permanent Message Header Field Names registry [RFC3864].

ヘッダ名
Sec-WebSocket-Extensions
適用可能なプロトコル
http
位置付け
標準 standard
作成/変更管理
IETF
仕様­文書
RFC 6455
関連情報
このヘッダは WebSocket opening ハンドシェイクにおいてのみ利用される。 This header field is only used for WebSocket opening handshake.

Sec-WebSocket-Extensions ヘッダは WebSocket opening ハンドシェイクの中で利用される。 クライアントからサーバへ初期­時に送信され,後続して,接続の間に利用するプロトコル­レベルの一連の拡張への同意を示すために,サーバからクライアントへ送信される。 The |Sec-WebSocket-Extensions| header field is used in the WebSocket opening handshake. It is initially sent from the client to the server, and then subsequently sent from the server to the client, to agree on a set of protocol-level extensions to use for the duration of the connection.

一個の HTTP リクエストの中に複数の Sec-WebSocket-Extensions ヘッダが出現してもよい(すべての値を含んでいる単独の Sec-WebSocket-Extensions ヘッダと論理的に同じ)。 しかしながら,一個の HTTP 応答の中では、複数の Sec-WebSocket-Extensions ヘッダが出現してはならない 正誤表による修正( Verified ):】 また、一個の HTTP 応答の中に複数の Sec-WebSocket-Extensions ヘッダが出現してもよい(すべての値を含んでいる単独の Sec-WebSocket-Extensions ヘッダと論理的に同じ)。 The |Sec-WebSocket-Extensions| header field MAY appear multiple times in an HTTP request (which is logically the same as a single |Sec-WebSocket-Extensions| header field that contains all values. However, the |Sec-WebSocket-Extensions| header field MUST NOT appear more than once in an HTTP response. The |Sec-WebSocket-Extensions| header field MAY appear multiple times in an HTTP response (which is logically the same as a single |Sec-WebSocket-Extensions| header field that contains all values).

11.3.3. Sec-WebSocket-Accept

この節では Permanent Message Header Field Names レジストリ [RFC3864] に登録されたヘッダを述べる。 This section describes a header field registered in the Permanent Message Header Field Names registry [RFC3864].

ヘッダ名
Sec-WebSocket-Accept
適用可能なプロトコル
http
位置付け
標準 standard
作成/変更管理
IETF
仕様­文書
RFC 6455
関連情報
このヘッダは WebSocket opening ハンドシェイクにおいてのみ利用される。 This header field is only used for the WebSocket opening handshake.

Sec-WebSocket-Accept ヘッダは WebSocket opening ハンドシェイクの中で利用される。 サーバが WebSocket 接続に起動する意向があることを立証するために、サーバからクライアントへ送信される。 The |Sec-WebSocket-Accept| header field is used in the WebSocket opening handshake. It is sent from the server to the client to confirm that the server is willing to initiate the WebSocket connection.

Sec-WebSocket-Accept ヘッダは、一個の HTTP 応答の中に複数回出現してはならない The |Sec-WebSocket-Accept| header MUST NOT appear more than once in an HTTP response.

11.3.4. Sec-WebSocket-Protocol

この節では Permanent Message Header Field Names レジストリ [RFC3864] に登録されたヘッダを述べる。 This section describes a header field registered in the Permanent Message Header Field Names registry [RFC3864].

ヘッダ名
Sec-WebSocket-Protocol
適用可能なプロトコル
http
位置付け
標準 standard
作成/変更管理
IETF
仕様­文書
RFC 6455
関連情報
このヘッダは WebSocket opening ハンドシェイクにおいてのみ利用される。 This header field is only used for the WebSocket opening handshake.

Sec-WebSocket-Protocol ヘッダは WebSocket opening ハンドシェイクの中で利用される。 接続の下位プロトコルの確認のために、クライアントからサーバへ送信され,サーバからクライアントへ返信される。 これにより,スクリプトは、下位プロトコルを選択した上で,サーバがその下位プロトコルの役務に同意したことを確かめられるようになる。 The |Sec-WebSocket-Protocol| header field is used in the WebSocket opening handshake. It is sent from the client to the server and back from the server to the client to confirm the subprotocol of the connection. This enables scripts to both select a subprotocol and be sure that the server agreed to serve that subprotocol.

一個の HTTP リクエストの中に複数の Sec-WebSocket-Protocol ヘッダが出現してもよい(すべての値を含んでいる単独の Sec-WebSocket-Protocol ヘッダと論理的に同じ)。 しかしながら,一個の HTTP 応答の中では,複数の Sec-WebSocket-Protocol ヘッダが出現してはならない The |Sec-WebSocket-Protocol| header field MAY appear multiple times in an HTTP request (which is logically the same as a single |Sec-WebSocket-Protocol| header field that contains all values). However, the |Sec-WebSocket-Protocol| header field MUST NOT appear more than once in an HTTP response.

11.3.5. Sec-WebSocket-Version

この節では、 Permanent Message Header Field Names レジストリ [RFC3864] に登録されたヘッダを述べる。 This section describes a header field registered in the Permanent Message Header Field Names registry [RFC3864].

ヘッダ名
Sec-WebSocket-Version
適用可能なプロトコル
http
位置付け
標準 standard
作成/変更管理
IETF
仕様­文書
RFC 6455
関連情報
このヘッダは WebSocket opening ハンドシェイクにおいてのみ利用される。 This header field is only used for the WebSocket opening handshake.

Sec-WebSocket-Version ヘッダは WebSocket opening ハンドシェイクにおいて利用される。 これは接続のプロトコル­バージョンを指示するために,クライアントからサーバへ送信される。 これにより、サーバは, opening ハンドシェイクとそのデータに後続して送信されたデータを正しく解釈でき、サーバがデータを安全な仕方で解釈できない場合には接続を close できるようになる。 Sec-WebSocket-Version ヘッダは、クライアントから受信されたバージョンがサーバが解せるバージョンに合致しないときの WebSocket ハンドシェイク­エラーの際にも,サーバからクライアントへ送信される。 その場合、このヘッダは,サーバでサポートされるプロトコル­バージョンを内包する。 The |Sec-WebSocket-Version| header field is used in the WebSocket opening handshake. It is sent from the client to the server to indicate the protocol version of the connection. This enables servers to correctly interpret the opening handshake and subsequent data being sent from the data, and close the connection if the server cannot interpret that data in a safe manner. The |Sec-WebSocket-Version| header field is also sent from the server to the client on WebSocket handshake error, when the version received from the client does not match a version understood by the server. In such a case, the header field includes the protocol version(s) supported by the server.

必ずしも、より上のバージョン番号が,より下のバージョン番号と後方互換であることは、期待されていないことに注意。 Note that there is no expectation that higher version numbers are necessarily backward compatible with lower version numbers.

一個の HTTP リクエストの中に Sec-WebSocket-Version ヘッダが複数回出現してもよい(すべての値を含んでいる単独の Sec-WebSocket-Version ヘッダと論理的に同じ)。 しかしながら,一個の HTTP 応答の中では、 Sec-WebSocket-Version ヘッダが複数回出現してはならない The |Sec-WebSocket-Version| header field MAY appear multiple times in an HTTP response (which is logically the same as a single |Sec-WebSocket-Version| header field that contains all values). However, the |Sec-WebSocket-Version| header field MUST NOT appear more than once in an HTTP request.

11.4. WebSocket 拡張名レジストリ

この仕様は、 [RFC5226] に提示される原則に則り, WebSocket Protocol と併用される WebSocket 拡張­名のための、新たな IANA レジストリを作成する。 This specification creates a new IANA registry for WebSocket Extension names to be used with the WebSocket Protocol in accordance with the principles set out in RFC 5226 [RFC5226].

このレジストリの一部として、 IANA は以下の情報を維持管理する: As part of this registry, IANA maintains the following information:

拡張­識別子
この仕様の 11.3.2 節 にて登録される, Sec-WebSocket-Extensions ヘッダに利用されることになる拡張の識別子。 値は、この仕様の 9.1 節 で定義されている extension-token に課される要件に適合しなければならない。 The identifier of the extension, as will be used in the |Sec-WebSocket-Extensions| header field registered in Section 11.3.2 of this specification. The value must conform to the requirements for an extension-token as defined in Section 9.1 of this specification.
拡張­共通名
拡張を一般に参照するための,拡張の名前。 The name of the extension, as the extension is generally referred to.
拡張­定義
WebSocket Protocol と伴用される拡張が定義される文書への参照 A reference to the document in which the extension being used with the WebSocket Protocol is defined.
既知の非互換­拡張
この拡張と非互換であることが既知である拡張の,識別子のリスト A list of extension identifiers with which this extension is known to be incompatible.

WebSocket Extension 名は、 "First Come First Served" IANA 登録ポリシー [RFC5226] の対象になる。 WebSocket Extension names are to be subject to the "First Come First Served" IANA registration policy [RFC5226].

このレジストリには初期­値は存在しない。 There are no initial values in this registry.

11.5. WebSocket 下位プロトコル名レジストリ

この仕様は、 [RFC5226] に提示される原則に則り, WebSocket Protocol と併用される WebSocket 下位プロトコル名のための、新たな IANA レジストリを作成する。 This specification creates a new IANA registry for WebSocket Subprotocol names to be used with the WebSocket Protocol in accordance with the principles set out in RFC 5226 [RFC5226].

このレジストリの一部として、 IANA は以下の情報を維持管理する: As part of this registry, IANA maintains the following information:

下位プロトコル識別子
この仕様の 11.3.4 節 にて登録される, Sec-WebSocket-Protocol ヘッダに利用されることになる,下位プロトコルの識別子。 値は、この仕様の 4.1 節第 10 項で与えられた要件に適合しなければならない — すなわち,値は、 [RFC2616] に定義されるトークン token 生成規則に合致】 でなければならない。 The identifier of the subprotocol, as will be used in the |Sec-WebSocket-Protocol| header field registered in Section 11.3.4 of this specification. The value must conform to the requirements given in item 10 of Section 4.1 of this specification -- namely, the value must be a token as defined by RFC 2616 [RFC2616].
下位プロトコル共通名
下位プロトコルを一般に参照するための,下位プロトコルの名前。 The name of the subprotocol, as the subprotocol is generally referred to.
下位プロトコル定義
WebSocket Protocol と伴用される下位プロトコルが定義される文書への参照 A reference to the document in which the subprotocol being used with the WebSocket Protocol is defined.

WebSocket Subprotocol 名は、 "First Come First Served" IANA 登録ポリシー [RFC5226] の対象になる。 WebSocket Subprotocol names are to be subject to the "First Come First Served" IANA registration policy [RFC5226].

11.6. WebSocket バージョン番号レジストリ

この仕様は、 [RFC5226] に提示される原則に則り, WebSocket Protocol と併用される WebSocket バージョン番号のための、新たな IANA レジストリを作成する。 This specification creates a new IANA registry for WebSocket Version Numbers to be used with the WebSocket Protocol in accordance with the principles set out in RFC 5226 [RFC5226].

このレジストリの一部として、 IANA は以下の情報を維持管理する: As part of this registry, IANA maintains the following information:

バージョン番号
Sec-WebSocket-Version ヘッダの中で利用されるバージョン番号は、この仕様の 4.1 節 にて指定される。 値は、 0 〜 255 の範囲の非負­整数でなければならない。 The version number to be used in the |Sec-WebSocket-Version| is specified in Section 4.1 of this specification. The value must be a non-negative integer in the range between 0 and 255 (inclusive).
参照
新たなバージョン番号またはバージョン番号を伴う草案の名前を要請している RFC (下を見よ)。 The RFC requesting a new version number or a draft name with version number (see below).
位置付け
"Interim" (暫定)または "Standard" (標準)のいずれか。 下の記述を見よ。 Either "Interim" or "Standard". See below for description.

バージョン番号は、 "Interim" または "Standard" として指定されている。 A version number is designated as either "Interim" or "Standard".

"Standard" バージョン番号は、RFC の中で文書­化され、この RFC で定義されるバージョンのような, WebSocket プロトコルのメジャーかつ安定的なバージョンを識別するために利用される。 "Standard" バージョン番号は、 "IETF Review" IANA 登録ポリシー [RFC5226] の対象になる。 A "Standard" version number is documented in an RFC and used to identify a major, stable version of the WebSocket protocol, such as the version defined by this RFC. "Standard" version numbers are subject to the "IETF Review" IANA registration policy [RFC5226].

"Interim" バージョン番号は、 Internet-Draft の中で文書­化され、この RFC の発行前に開発されたバージョンなど,実装者による, WebSocket プロトコルの頒布バージョンとの識別や相互運用を支援するために利用される。 "Interim" バージョン番号は、initial Designated Experts である HYBI Working Group の chairs(または, working group が解散したときは, IETF Applications Area の Area Directors )からの, "Expert Review" IANA 登録ポリシー [RFC5226] の対象になる。 An "Interim" version number is documented in an Internet-Draft and used to help implementors identify and interoperate with deployed versions of the WebSocket protocol, such as versions developed before the publication of this RFC. "Interim" version numbers are subject to the "Expert Review" IANA registration policy [RFC5226], with the chairs of the HYBI Working Group (or, if the working group closes, the Area Directors for the IETF Applications Area) being the initial Designated Experts.

IANA は、以下の,レジストリの初期­値を追加した。 IANA has added initial values to the registry as follows.

バージョン番号 参照 位置付け
0 draft-ietf-hybi-thewebsocketprotocol-00 Interim
1 draft-ietf-hybi-thewebsocketprotocol-01 Interim
2 draft-ietf-hybi-thewebsocketprotocol-02 Interim
3 draft-ietf-hybi-thewebsocketprotocol-03 Interim
4 draft-ietf-hybi-thewebsocketprotocol-04 Interim
5 draft-ietf-hybi-thewebsocketprotocol-05 Interim
6 draft-ietf-hybi-thewebsocketprotocol-06 Interim
7 draft-ietf-hybi-thewebsocketprotocol-07 Interim
8 draft-ietf-hybi-thewebsocketprotocol-08 Interim
9Reserved
10Reserved
11Reserved
12Reserved
13RFC 6455Standard

11.7. WebSocket close コード番号レジストリ

この仕様は、 [RFC5226] に提示される原則に則り, WebSocket Protocol と併用される WebSocket close コード番号のための、新たな IANA レジストリを作成する。 This specification creates a new IANA registry for WebSocket Connection Close Code Numbers in accordance with the principles set out in RFC 5226 [RFC5226].

このレジストリの一部として、 IANA は以下の情報を維持管理する: As part of this registry, IANA maintains the following information:

ステータスコード
Status Code は、この文書の 7.4 節 に従って WebSocket 接続 closure の事由を表す。 ステータスコードは 1000 〜 4999 の範囲の整数である。 The Status Code denotes a reason for a WebSocket connection closure as per Section 7.4 of this document. The status code is an integer number between 1000 and 4999 (inclusive).
意味
ステータスコードが持つ意味。 それぞれのステータスコードは一意的な意味を持っていなければならない。 The meaning of the status code. Each status code has to have a unique meaning.
連絡先
ステータスコードを予約した主体の連絡先。 A contact for the entity reserving the status code.
参照
ステータスコードとそれらの意味の定義を要請している安定的な文書。 これは、範囲 1000-2999 のステータスコードに要求され,範囲 3000-3999 のステータスコードに推奨される。 The stable document requesting the status codes and defining their meaning. This is required for status codes in the range 1000-2999 and recommended for status codes in the range 3000-3999.

WebSocket Close Code Numbers は、それらの範囲に依存して,異なる登録­要件の対象になる。 [ このプロトコルとその後続バージョン, または拡張 ]用途のステータスコードの要請は[ "Standards Action", "Specification Required" ( "Designated Expert" も伴われることになる), "IESG Review" IANA 登録ポリシー ]のいずれかの対象になり、範囲 1000-2999 に対して認可されるべきである。 [ ライブラリ/フレームワーク/アプリケーション ]用途のステータスコードの要請は、 “First Come First Served" IANA 登録ポリシーの対象になり、範囲 3000-3999 に対して認可されるべきである。 範囲 4000-4999 のステータスコードは Private Use (私的利用)の指定を受けている。 その要請は、[ WebSocket Protocol (またはその将来バージョン) / 拡張 / [ ライブラリ/フレームワーク/アプリケーション ]]の,どの用途でステータスコードを要請しているかを指示するべきである。 WebSocket Close Code Numbers are subject to different registration requirements depending on their range. Requests for status codes for use by this protocol and its subsequent versions or extensions are subject to any one of the "Standards Action", "Specification Required" (which implies "Designated Expert"), or "IESG Review" IANA registration policies and should be granted in the range 1000-2999. Requests for status codes for use by libraries, frameworks, and applications are subject to the "First Come First Served" IANA registration policy and should be granted in the range 3000-3999. The range of status codes from 4000-4999 is designated for Private Use. Requests should indicate whether they are requesting status codes for use by the WebSocket Protocol (or a future version of the protocol), by extensions, or by libraries/frameworks/applications.

IANA は、以下のレジストリの初期­値を追加した。 IANA has added initial values to the registry as follows.

ステータスコード 意味 連絡先 参照
1000 正常な closure Normal Closure hybi@ietf.orgRFC 6455
1001 消失 Going Away hybi@ietf.orgRFC 6455
1002 プロトコル­エラー Protocol error hybi@ietf.orgRFC 6455
1003 未サポートのデータ Unsupported Data hybi@ietf.orgRFC 6455
1004 ---予約済み---- ---Reserved---- hybi@ietf.orgRFC 6455
1005 ステータスが受信されなかった No Status Rcvd hybi@ietf.orgRFC 6455
1006 異常な closure Abnormal Closure hybi@ietf.orgRFC 6455
1007 妥当でないフレーム ペイロード­データInvalid frame payload data hybi@ietf.orgRFC 6455
1008 ポリシー違反 Policy Violation hybi@ietf.orgRFC 6455
1009 大き過ぎるメッセージ Message Too Big hybi@ietf.orgRFC 6455
1010 必須の拡張Mandatory Ext. hybi@ietf.orgRFC 6455
1011 サーバ内部のエラー Internal Server Error hybi@ietf.orgRFC 6455
1015 TLS ハンドシェイク TLS handshake hybi@ietf.orgRFC 6455

11.8. WebSocket opcode レジストリ

この仕様は、 [RFC5226] に提示される原則に則り, WebSocket Protocol と併用される WebSocket opcode のための、新たな IANA レジストリを作成する。 This specification creates a new IANA registry for WebSocket Opcodes in accordance with the principles set out in RFC 5226 [RFC5226].

このレジストリの一部として、 IANA は以下の情報を維持管理する: As part of this registry, IANA maintains the following information:

Opcode
opcode は、WebSocket フレームのフレーム種別を表す。 5.2 節 の定義に従って, opcode は、 0 〜 15 の範囲の整数である。 The opcode denotes the frame type of the WebSocket frame, as defined in Section 5.2. The opcode is an integer number between 0 and 15, inclusive.
意味
opcode 値の意味。 The meaning of the opcode value.
参照
opcode を要請している仕様。 The specification requesting the opcode.

WebSocket Opcode 番号は、 "Standards Action" IANA 登録ポリシー [RFC5226] の対象である。 WebSocket Opcode numbers are subject to the "Standards Action" IANA registration policy [RFC5226].

IANA は、以下のレジストリの初期­値を追加した。 IANA has added initial values to the registry as follows.

Opcode 意味 参照
0 Continuation FrameRFC 6455
1 Text FrameRFC 6455
2 Binary FrameRFC 6455
8 Connection Close FrameRFC 6455
9 Ping FrameRFC 6455
10Pong FrameRFC 6455

11.9. WebSocket フレーミング ヘッダ ビット レジストリ

この仕様は、 [RFC5226] に提示される原則に則り, WebSocket Protocol と併用される WebSocket フレーミング ヘッダ ビットのための、新たな IANA レジストリを作成する。 このレジストリは、 5.2 節 の RSV1, RSV2, RSV3 ビットの割り当てを統制する。 This specification creates a new IANA registry for WebSocket Framing Header Bits in accordance with the principles set out in RFC 5226 [RFC5226]. This registry controls assignment of the bits marked RSV1, RSV2, and RSV3 in Section 5.2.

これらのビットは、この仕様の将来バージョンまたは拡張のために,予約済みである。 These bits are reserved for future versions or extensions of this specification.

WebSocket Framing Header Bits の割り当ては、 "Standards Action" IANA 登録ポリシー [RFC5226] の対象になる。 WebSocket Framing Header Bits assignments are subject to the "Standards Action" IANA registration policy [RFC5226].

12. 他の仕様からの WebSocket プロトコルの利用

WebSocket Protocol は、動的な作者定義の内容のための,汎用の仕組みを提供するためのものとして、他の仕様からの利用が意図されている。 例えば,スクリプトのための API を定義する仕様の中で。 The WebSocket Protocol is intended to be used by another specification to provide a generic mechanism for dynamic author-defined content, e.g., in a specification defining a scripted API.

その種の仕様は、まず,次に挙げるものを伴うアルゴリズムを提供して WebSocket Connection を確立 する必要がある: Such a specification first needs to _Establish a WebSocket Connection_, providing that algorithm with:

host, port, resource-name, secure フラグは、通常, WebSocket URI の成分を構文解析する手続きを用いて URI から得られる。 これらの手続きは、 URI が WebSocket を指定していなければ失敗する。 The /host/, /port/, /resource name/, and /secure/ flag are usually obtained from a URI using the steps to parse a WebSocket URI's components. These steps fail if the URI does not specify a WebSocket.

接続が close されることになるときは,いつでも、仕様は WebSocket 接続を close する アルゴリズムを利用する必要がある( 7.1.1 節 )。 If at any time the connection is to be closed, then the specification needs to use the _Close the WebSocket Connection_ algorithm (Section 7.1.1).

いつ WebSocket 接続が close される かは、 7.1.4 節 にて定義されている。 Section 7.1.4 defines when _The WebSocket Connection is Closed_.

接続が open の間、仕様は WebSocket メッセージが受信された6.2 節 )ときの場合を取り扱う必要がある。 While a connection is open, the specification will need to handle the cases when _A WebSocket Message Has Been Received_ (Section 6.2).

何らかのデータを open 接続に送信するためには、仕様は WebSocket メッセージを送信する 必要がある( 6.1 節 )。 To send some data /data/ to an open connection, the specification needs to _Send a WebSocket Message_ (Section 6.1).

13. 謝辞

このプロトコルの元々の著者であり,編集者であった Ian Hickson 氏に特別な謝意を。 この仕様の初期の設計は、WHATWG と WHATWG のメーリングリストの多数の人々の関与から恩恵を受けている。 その仕様に対する寄与は、節として記録されてはいないが,その仕様に寄与された方々すべての一覧は、 http://whatwg.org/html5 の WHATWG HTML 仕様に掲載されている。 Special thanks are due to Ian Hickson, who was the original author and editor of this protocol. The initial design of this specification benefitted from the participation of many people in the WHATWG and WHATWG mailing list. Contributions to that specification are not tracked by section, but a list of all who contributed to that specification is given in the WHATWG HTML specification at http://whatwg.org/html5.

この仕様の "Data Framing" 節に,多量の文章を寄稿してくれた John Tamplin 氏に特別な謝意を。 Special thanks also to John Tamplin for providing a significant amount of text for the "Data Framing" section of this specification.

この仕様の "Data Masking" 節に,多量の文章と背景調査を寄稿/提供してくれた Adam Barth 氏に特別な謝意を。 Special thanks also to Adam Barth for providing a significant amount of text and background research for the "Data Masking" section of this specification.

Lisa Dusseault 氏からの Apps Area 評価(と,この仕事の開始の支援に), Richard Barnes 氏からの Gen-Art 評価, Magnus Westerlund 氏からの Transport Area Review に特別な謝意を。 舞台裏で不断に働き,この仕事を完了に向けて推進した過去の HYBI WG および現在の WG chairs に特別な謝意を: Joe Hildebrand, Salvatore Loreto, Gabriel Montenegro 氏。 前述のすべてに加えて, responsible Area Director の Peter Saint-Andre 氏に特別な謝意を。 Special thanks to Lisa Dusseault for the Apps Area review (and for helping to start this work), Richard Barnes for the Gen-Art review, and Magnus Westerlund for the Transport Area Review. Special thanks to HYBI WG past and present WG chairs who tirelessly worked behind the scene to move this work toward completion: Joe Hildebrand, Salvatore Loreto, and Gabriel Montenegro. And last but not least, special thank you to the responsible Area Director Peter Saint-Andre.

HYBI WG メーリングリストの議論に加わり,アイデアや詳細な評価を提供された次の方々に謝意を(この一覧はおそらく完全でない): Thank you to the following people who participated in discussions on the HYBI WG mailing list and contributed ideas and/or provided detailed reviews (the list is likely to be incomplete):

Greg Wilkins, John Tamplin, Willy Tarreau, Maciej Stachowiak, Jamie Lokier, Scott Ferguson, Bjoern Hoehrmann, Julian Reschke, Dave Cridland, Andy Green, Eric Rescorla, Inaki Baz Castillo, Martin Thomson, Roberto Peon, Patrick McManus, Zhong Yu, Bruce Atherton, Takeshi Yoshino, Martin J. Duerst, James Graham, Simon Pieters, Roy T. Fielding, Mykyta Yevstifeyev, Len Holgate, Paul Colomiets, Piotr Kulaga, Brian Raymor, Jan Koehler, Joonas Lehtolahti, Sylvain Hellegouarch, Stephen Farrell, Sean Turner, Pete Resnick, Peter Thorson, Joe Mason, John Fallows, and Alexander Philippou.

上に挙げられているからと言って、彼らがこの仕事の最終成果を承認していることを意味するわけではないことに注意。 Note that people listed above didn't necessarily endorse the end result of this work.

14. 参照文献

14.1. 文献(規範的)

[ANSI.X3-4.1986]
American National Standards Institute, "Coded Character Set - 7-bit American Standard Code for Information Interchange", ANSI X3.4, 1986.
[FIPS.180-3]
National Institute of Standards and Technology, "Secure Hash Standard", FIPS PUB 180-3, October 2008, <http://csrc.nist.gov/publications/fips/fips180-3/fips180-3_final.pdf>.
[RFC1928]
Leech, M., Ganis, M., Lee, Y., Kuris, R., Koblas, D., and L. Jones, "SOCKS Protocol Version 5", RFC 1928, March 1996.
[RFC2119]
Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, March 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.
[RFC3629]
Yergeau, F., "UTF-8, a transformation format of ISO 10646", STD 63, RFC 3629, November 2003.
[RFC3864]
Klyne, G., Nottingham, M., and J. Mogul, "Registration Procedures for Message Header Fields", BCP 90, RFC 3864, September 2004.
[RFC3986]
Berners-Lee, T., Fielding, R., and L. Masinter, "Uniform Resource Identifier (URI): Generic Syntax", STD 66, RFC 3986, January 2005.
[RFC3987]
Duerst, M. and M. Suignard, "Internationalized Resource Identifiers (IRIs)", RFC 3987, January 2005.
[RFC4086]
Eastlake, D., Schiller, J., and S. Crocker, "Randomness Requirements for Security", BCP 106, RFC 4086, June 2005.
[RFC4648]
Josefsson, S., "The Base16, Base32, and Base64 Data Encodings", RFC 4648, October 2006.
[RFC5226]
Narten, T. and H. Alvestrand, "Guidelines for Writing an IANA Considerations Section in RFCs", BCP 26, RFC 5226, May 2008.
[RFC5234]
Crocker, D. and P. Overell, "Augmented BNF for Syntax Specifications: ABNF", STD 68, RFC 5234, January 2008.
[RFC5246]
Dierks, T. and E. Rescorla, "The Transport Layer Security (TLS) Protocol Version 1.2", RFC 5246, August 2008.
[RFC6066]
Eastlake, D., "Transport Layer Security (TLS) Extensions: Extension Definitions", RFC 6066, January 2011.
[RFC6454]
Barth, A., "The Web Origin Concept", RFC 6454, December 2011.

14.2. 文献(参考)

[RFC4122]
Leach, P., Mealling, M., and R. Salz, "A Universally Unique IDentifier (UUID) URN Namespace", RFC 4122, July 2005.
[RFC4270]
Hoffman, P. and B. Schneier, "Attacks on Cryptographic Hashes in Internet Protocols", RFC 4270, November 2005.
[RFC5321]
Klensin, J., "Simple Mail Transfer Protocol", RFC 5321, October 2008.
[RFC6202]
Loreto, S., Saint-Andre, P., Salsano, S., and G. Wilkins, "Known Issues and Best Practices for the Use of Long Polling and Streaming in Bidirectional HTTP", RFC 6202, April 2011.
[RFC6265]
Barth, A., "HTTP State Management Mechanism", RFC 6265, April 2011.
[TALKING]
Huang, L-S., Chen, E., Barth, A., Rescorla, E., and C. Jackson, "Talking to Yourself for Fun and Profit", 2010, <http://w2spconf.com/2011/papers/websocket.pdf>.
[W3C.REC-wsc-ui-20100812]
Roessler, T. and A. Saldhana, "Web Security Context: User Interface Guidelines", World Wide Web Consortium Recommendation REC-wsc-ui-20100812, August 2010, <http://www.w3.org/TR/2010/REC-wsc-ui-20100812/>.
Latest version available at <http://www.w3.org/TR/wsc-ui/>.
[WSAPI]
Hickson, I., "The WebSocket API", W3C Working Draft WD- websockets-20110929, September 2011, <http://www.w3.org/TR/2011/WD-websockets-20110929/>.
Latest version available at <http://www.w3.org/TR/websockets/>.
[XMLHttpRequest]
van Kesteren, A., Ed., "XMLHttpRequest", W3C Candidate Recommendation CR-XMLHttpRequest-20100803, August 2010, <http://www.w3.org/TR/2010/CR-XMLHttpRequest-20100803/>.
Latest version available at <http://www.w3.org/TR/XMLHttpRequest/>.