| // Copyright 2018 The Chromium Authors | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| #include "services/network/public/cpp/server/web_socket.h" | |
| #include <vector> | |
| #include "base/base64.h" | |
| #include "base/check.h" | |
| #include "base/hash/sha1.h" | |
| #include "base/strings/string_number_conversions.h" | |
| #include "base/strings/stringprintf.h" | |
| #include "base/sys_byteorder.h" | |
| #include "net/websockets/websocket_deflate_parameters.h" | |
| #include "net/websockets/websocket_extension.h" | |
| #include "net/websockets/websocket_handshake_constants.h" | |
| #include "services/network/public/cpp/server/http_connection.h" | |
| #include "services/network/public/cpp/server/http_server.h" | |
| #include "services/network/public/cpp/server/http_server_request_info.h" | |
| #include "services/network/public/cpp/server/http_server_response_info.h" | |
| #include "services/network/public/cpp/server/web_socket_encoder.h" | |
| namespace network { | |
| namespace server { | |
| namespace { | |
| std::string ExtensionsHeaderString( | |
| const std::vector<net::WebSocketExtension>& extensions) { | |
| if (extensions.empty()) | |
| return std::string(); | |
| std::string result = "Sec-WebSocket-Extensions: " + extensions[0].ToString(); | |
| for (size_t i = 1; i < extensions.size(); ++i) | |
| result += ", " + extensions[i].ToString(); | |
| return result + "\r\n"; | |
| } | |
| std::string ValidResponseString( | |
| const std::string& accept_hash, | |
| const std::vector<net::WebSocketExtension> extensions) { | |
| return base::StringPrintf( | |
| "HTTP/1.1 101 WebSocket Protocol Handshake\r\n" | |
| "Upgrade: WebSocket\r\n" | |
| "Connection: Upgrade\r\n" | |
| "Sec-WebSocket-Accept: %s\r\n" | |
| "%s" | |
| "\r\n", | |
| accept_hash.c_str(), ExtensionsHeaderString(extensions).c_str()); | |
| } | |
| } // namespace | |
| WebSocket::WebSocket(HttpServer* server, HttpConnection* connection) | |
| : server_(server), connection_(connection), closed_(false) {} | |
| WebSocket::~WebSocket() = default; | |
| void WebSocket::Accept( | |
| const HttpServerRequestInfo& request, | |
| const net::NetworkTrafficAnnotationTag traffic_annotation) { | |
| std::string version = request.GetHeaderValue("sec-websocket-version"); | |
| if (version != "8" && version != "13") { | |
| SendErrorResponse("Invalid request format. The version is not valid.", | |
| traffic_annotation); | |
| return; | |
| } | |
| std::string key = request.GetHeaderValue("sec-websocket-key"); | |
| if (key.empty()) { | |
| SendErrorResponse( | |
| "Invalid request format. Sec-WebSocket-Key is empty or isn't " | |
| "specified.", | |
| traffic_annotation); | |
| return; | |
| } | |
| std::string encoded_hash; | |
| base::Base64Encode( | |
| base::SHA1HashString(key + net::websockets::kWebSocketGuid), | |
| &encoded_hash); | |
| std::vector<net::WebSocketExtension> response_extensions; | |
| auto i = request.headers.find("sec-websocket-extensions"); | |
| if (i == request.headers.end()) { | |
| encoder_ = WebSocketEncoder::CreateServer(); | |
| } else { | |
| net::WebSocketDeflateParameters params; | |
| encoder_ = WebSocketEncoder::CreateServer(i->second, ¶ms); | |
| if (!encoder_) { | |
| Fail(); | |
| return; | |
| } | |
| if (encoder_->deflate_enabled()) { | |
| DCHECK(params.IsValidAsResponse()); | |
| response_extensions.push_back(params.AsExtension()); | |
| } | |
| } | |
| server_->SendRaw(connection_->id(), | |
| ValidResponseString(encoded_hash, response_extensions), | |
| traffic_annotation); | |
| traffic_annotation_ = std::make_unique<net::NetworkTrafficAnnotationTag>( | |
| net::NetworkTrafficAnnotationTag(traffic_annotation)); | |
| } | |
| WebSocket::ParseResult WebSocket::Read(std::string* message) { | |
| if (closed_) | |
| return FRAME_CLOSE; | |
| if (!encoder_) { | |
| // RFC6455, section 4.1 says "Once the client's opening handshake has been | |
| // sent, the client MUST wait for a response from the server before sending | |
| // any further data". If |encoder_| is null here, ::Accept either has not | |
| // been called at all, or has rejected a request rather than producing | |
| // a server handshake. Either way, the client clearly couldn't have gotten | |
| // a proper server handshake, so error out, especially since this method | |
| // can't proceed without an |encoder_|. | |
| return FRAME_ERROR; | |
| } | |
| const std::string& read_buf = connection_->read_buf(); | |
| base::StringPiece frame(read_buf); | |
| int bytes_consumed = 0; | |
| const ParseResult result = | |
| encoder_->DecodeFrame(frame, &bytes_consumed, message); | |
| frame = frame.substr(bytes_consumed); | |
| connection_->read_buf().erase(0, bytes_consumed); | |
| if (result == FRAME_CLOSE) | |
| closed_ = true; | |
| if (result == FRAME_PING) { | |
| DCHECK(traffic_annotation_); | |
| Send(*message, net::WebSocketFrameHeader::kOpCodePong, | |
| *traffic_annotation_); | |
| } | |
| return result; | |
| } | |
| void WebSocket::Send( | |
| base::StringPiece message, | |
| net::WebSocketFrameHeader::OpCodeEnum op_code, | |
| const net::NetworkTrafficAnnotationTag traffic_annotation) { | |
| if (closed_) | |
| return; | |
| std::string encoded; | |
| switch (op_code) { | |
| case net::WebSocketFrameHeader::kOpCodeText: | |
| encoder_->EncodeTextFrame(message, 0, &encoded); | |
| break; | |
| case net::WebSocketFrameHeader::kOpCodePong: | |
| encoder_->EncodePongFrame(message, 0, &encoded); | |
| break; | |
| default: | |
| // Only Pong and Text frame types are supported. | |
| NOTREACHED(); | |
| } | |
| server_->SendRaw(connection_->id(), encoded, traffic_annotation); | |
| } | |
| void WebSocket::Fail() { | |
| closed_ = true; | |
| // TODO(yhirano): The server SHOULD log the problem. | |
| server_->Close(connection_->id()); | |
| } | |
| void WebSocket::SendErrorResponse( | |
| const std::string& message, | |
| const net::NetworkTrafficAnnotationTag traffic_annotation) { | |
| if (closed_) | |
| return; | |
| closed_ = true; | |
| server_->Send500(connection_->id(), message, traffic_annotation); | |
| } | |
| } // namespace server | |
| } // namespace network |