blob: bd622ffa7c1223b80bf21a40d0afa60d93003361 [file] [log] [blame]
// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "net/websockets/websocket_basic_stream.h"
#include <stddef.h>
#include <stdint.h>
#include <algorithm>
#include <limits>
#include <utility>
#include "base/bind.h"
#include "base/command_line.h"
#include "base/logging.h"
#include "base/numerics/safe_conversions.h"
#include "base/strings/string_number_conversions.h"
#include "build/build_config.h"
#include "net/base/io_buffer.h"
#include "net/base/net_errors.h"
#include "net/socket/client_socket_handle.h"
#include "net/websockets/websocket_basic_stream_adapters.h"
#include "net/websockets/websocket_errors.h"
#include "net/websockets/websocket_frame.h"
namespace net {
namespace {
// Please refer to the comment in class header if the usage changes.
constexpr net::NetworkTrafficAnnotationTag kTrafficAnnotation =
net::DefineNetworkTrafficAnnotation("websocket_basic_stream", R"(
semantics {
sender: "WebSocket Basic Stream"
description:
"Implementation of WebSocket API from web content (a page the user "
"visits)."
trigger: "Website calls the WebSocket API."
data:
"Any data provided by web content, masked and framed in accordance "
"with RFC6455."
destination: OTHER
destination_other:
"The address that the website has chosen to communicate to."
}
policy {
cookies_allowed: YES
cookies_store: "user"
setting: "These requests cannot be disabled."
policy_exception_justification:
"Not implemented. WebSocket is a core web platform API."
}
comments:
"The browser will never add cookies to a WebSocket message. But the "
"handshake that was performed when the WebSocket connection was "
"established may have contained cookies."
)");
// This uses type uint64_t to match the definition of
// WebSocketFrameHeader::payload_length in websocket_frame.h.
const uint64_t kMaxControlFramePayload = 125;
// The number of bytes to attempt to read at a time.
// TODO(ricea): See if there is a better number or algorithm to fulfill our
// requirements:
// 1. We would like to use minimal memory on low-bandwidth or idle connections
// 2. We would like to read as close to line speed as possible on
// high-bandwidth connections
// 3. We can't afford to cause jank on the IO thread by copying large buffers
// around
// 4. We would like to hit any sweet-spots that might exist in terms of network
// packet sizes / encryption block sizes / IPC alignment issues, etc.
#if defined(OS_ANDROID)
const int kReadBufferSize = 32 * 1024;
#else
// |2^n - delta| is better than 2^n on Linux. See crrev.com/c/1792208.
const int kReadBufferSize = 131000;
#endif
// Returns the total serialized size of |frames|. This function assumes that
// |frames| will be serialized with mask field. This function forces the
// masked bit of the frames on.
int CalculateSerializedSizeAndTurnOnMaskBit(
std::vector<std::unique_ptr<WebSocketFrame>>* frames) {
const uint64_t kMaximumTotalSize = std::numeric_limits<int>::max();
uint64_t total_size = 0;
for (const auto& frame : *frames) {
// Force the masked bit on.
frame->header.masked = true;
// We enforce flow control so the renderer should never be able to force us
// to cache anywhere near 2GB of frames.
uint64_t frame_size = frame->header.payload_length +
GetWebSocketFrameHeaderSize(frame->header);
CHECK_LE(frame_size, kMaximumTotalSize - total_size)
<< "Aborting to prevent overflow";
total_size += frame_size;
}
return static_cast<int>(total_size);
}
} // namespace
// Overrides default read buffer size for WebSocket. This flag will be used to
// investigate the performance issue of crbug.com/865001 and be deleted later
// on.
const char kWebSocketReadBufferSize[] = "websocket-read-buffer-size";
WebSocketBasicStream::WebSocketBasicStream(
std::unique_ptr<Adapter> connection,
const scoped_refptr<GrowableIOBuffer>& http_read_buffer,
const std::string& sub_protocol,
const std::string& extensions)
: connection_(std::move(connection)),
http_read_buffer_(http_read_buffer),
sub_protocol_(sub_protocol),
extensions_(extensions),
generate_websocket_masking_key_(&GenerateWebSocketMaskingKey) {
// http_read_buffer_ should not be set if it contains no data.
if (http_read_buffer_.get() && http_read_buffer_->offset() == 0)
http_read_buffer_ = nullptr;
DCHECK(connection_->is_initialized());
base::CommandLine* const command_line =
base::CommandLine::ForCurrentProcess();
DCHECK(command_line);
int websocket_buffer_size = kReadBufferSize;
if (command_line->HasSwitch(kWebSocketReadBufferSize)) {
std::string size_string =
command_line->GetSwitchValueASCII(kWebSocketReadBufferSize);
if (!base::StringToInt(size_string, &websocket_buffer_size) ||
websocket_buffer_size <= 0) {
websocket_buffer_size = kReadBufferSize;
}
}
DVLOG(1) << "WebSocketReadBufferSize is " << websocket_buffer_size;
read_buffer_ =
(base::MakeRefCounted<IOBufferWithSize>(websocket_buffer_size));
}
WebSocketBasicStream::~WebSocketBasicStream() { Close(); }
int WebSocketBasicStream::ReadFrames(
std::vector<std::unique_ptr<WebSocketFrame>>* frames,
CompletionOnceCallback callback) {
read_callback_ = std::move(callback);
complete_control_frame_body_.clear();
if (http_read_buffer_ && is_http_read_buffer_decoded_) {
http_read_buffer_.reset();
}
return ReadEverything(frames);
}
int WebSocketBasicStream::WriteFrames(
std::vector<std::unique_ptr<WebSocketFrame>>* frames,
CompletionOnceCallback callback) {
// This function always concatenates all frames into a single buffer.
// TODO(ricea): Investigate whether it would be better in some cases to
// perform multiple writes with smaller buffers.
write_callback_ = std::move(callback);
// First calculate the size of the buffer we need to allocate.
int total_size = CalculateSerializedSizeAndTurnOnMaskBit(frames);
auto combined_buffer = base::MakeRefCounted<IOBufferWithSize>(total_size);
char* dest = combined_buffer->data();
int remaining_size = total_size;
for (const auto& frame : *frames) {
WebSocketMaskingKey mask = generate_websocket_masking_key_();
int result =
WriteWebSocketFrameHeader(frame->header, &mask, dest, remaining_size);
DCHECK_NE(ERR_INVALID_ARGUMENT, result)
<< "WriteWebSocketFrameHeader() says that " << remaining_size
<< " is not enough to write the header in. This should not happen.";
CHECK_GE(result, 0) << "Potentially security-critical check failed";
dest += result;
remaining_size -= result;
CHECK_LE(frame->header.payload_length,
static_cast<uint64_t>(remaining_size));
const int frame_size = static_cast<int>(frame->header.payload_length);
if (frame_size > 0) {
const char* const frame_data = frame->payload;
std::copy(frame_data, frame_data + frame_size, dest);
MaskWebSocketFramePayload(mask, 0, dest, frame_size);
dest += frame_size;
remaining_size -= frame_size;
}
}
DCHECK_EQ(0, remaining_size) << "Buffer size calculation was wrong; "
<< remaining_size << " bytes left over.";
auto drainable_buffer = base::MakeRefCounted<DrainableIOBuffer>(
combined_buffer.get(), total_size);
return WriteEverything(drainable_buffer);
}
void WebSocketBasicStream::Close() {
connection_->Disconnect();
}
std::string WebSocketBasicStream::GetSubProtocol() const {
return sub_protocol_;
}
std::string WebSocketBasicStream::GetExtensions() const { return extensions_; }
/*static*/
std::unique_ptr<WebSocketBasicStream>
WebSocketBasicStream::CreateWebSocketBasicStreamForTesting(
std::unique_ptr<ClientSocketHandle> connection,
const scoped_refptr<GrowableIOBuffer>& http_read_buffer,
const std::string& sub_protocol,
const std::string& extensions,
WebSocketMaskingKeyGeneratorFunction key_generator_function) {
auto stream = std::make_unique<WebSocketBasicStream>(
std::make_unique<WebSocketClientSocketHandleAdapter>(
std::move(connection)),
http_read_buffer, sub_protocol, extensions);
stream->generate_websocket_masking_key_ = key_generator_function;
return stream;
}
int WebSocketBasicStream::ReadEverything(
std::vector<std::unique_ptr<WebSocketFrame>>* frames) {
DCHECK(frames->empty());
// If there is data left over after parsing the HTTP headers, attempt to parse
// it as WebSocket frames.
if (http_read_buffer_.get() && !is_http_read_buffer_decoded_) {
DCHECK_GE(http_read_buffer_->offset(), 0);
is_http_read_buffer_decoded_ = true;
std::vector<std::unique_ptr<WebSocketFrameChunk>> frame_chunks;
if (!parser_.Decode(http_read_buffer_->StartOfBuffer(),
http_read_buffer_->offset(), &frame_chunks))
return WebSocketErrorToNetError(parser_.websocket_error());
if (!frame_chunks.empty()) {
int result = ConvertChunksToFrames(&frame_chunks, frames);
if (result != ERR_IO_PENDING)
return result;
}
}
// Run until socket stops giving us data or we get some frames.
while (true) {
// base::Unretained(this) here is safe because net::Socket guarantees not to
// call any callbacks after Disconnect(), which we call from the destructor.
// The caller of ReadEverything() is required to keep |frames| valid.
int result = connection_->Read(
read_buffer_.get(), read_buffer_->size(),
base::BindOnce(&WebSocketBasicStream::OnReadComplete,
base::Unretained(this), base::Unretained(frames)));
if (result == ERR_IO_PENDING)
return result;
result = HandleReadResult(result, frames);
if (result != ERR_IO_PENDING)
return result;
DCHECK(frames->empty());
}
}
void WebSocketBasicStream::OnReadComplete(
std::vector<std::unique_ptr<WebSocketFrame>>* frames,
int result) {
result = HandleReadResult(result, frames);
if (result == ERR_IO_PENDING)
result = ReadEverything(frames);
if (result != ERR_IO_PENDING)
std::move(read_callback_).Run(result);
}
int WebSocketBasicStream::WriteEverything(
const scoped_refptr<DrainableIOBuffer>& buffer) {
while (buffer->BytesRemaining() > 0) {
// The use of base::Unretained() here is safe because on destruction we
// disconnect the socket, preventing any further callbacks.
int result = connection_->Write(
buffer.get(), buffer->BytesRemaining(),
base::BindOnce(&WebSocketBasicStream::OnWriteComplete,
base::Unretained(this), buffer),
kTrafficAnnotation);
if (result > 0) {
buffer->DidConsume(result);
} else {
return result;
}
}
return OK;
}
void WebSocketBasicStream::OnWriteComplete(
const scoped_refptr<DrainableIOBuffer>& buffer,
int result) {
if (result < 0) {
DCHECK_NE(ERR_IO_PENDING, result);
std::move(write_callback_).Run(result);
return;
}
DCHECK_NE(0, result);
buffer->DidConsume(result);
result = WriteEverything(buffer);
if (result != ERR_IO_PENDING)
std::move(write_callback_).Run(result);
}
int WebSocketBasicStream::HandleReadResult(
int result,
std::vector<std::unique_ptr<WebSocketFrame>>* frames) {
DCHECK_NE(ERR_IO_PENDING, result);
DCHECK(frames->empty());
if (result < 0)
return result;
if (result == 0)
return ERR_CONNECTION_CLOSED;
std::vector<std::unique_ptr<WebSocketFrameChunk>> frame_chunks;
if (!parser_.Decode(read_buffer_->data(), result, &frame_chunks))
return WebSocketErrorToNetError(parser_.websocket_error());
if (frame_chunks.empty())
return ERR_IO_PENDING;
return ConvertChunksToFrames(&frame_chunks, frames);
}
int WebSocketBasicStream::ConvertChunksToFrames(
std::vector<std::unique_ptr<WebSocketFrameChunk>>* frame_chunks,
std::vector<std::unique_ptr<WebSocketFrame>>* frames) {
for (size_t i = 0; i < frame_chunks->size(); ++i) {
auto& chunk = (*frame_chunks)[i];
DCHECK(chunk == frame_chunks->back() || chunk->final_chunk)
<< "Only last chunk can have |final_chunk| set to be false.";
std::unique_ptr<WebSocketFrame> frame;
int result = ConvertChunkToFrame(std::move(chunk), &frame);
if (result != OK)
return result;
if (frame)
frames->push_back(std::move(frame));
}
frame_chunks->clear();
if (frames->empty())
return ERR_IO_PENDING;
return OK;
}
int WebSocketBasicStream::ConvertChunkToFrame(
std::unique_ptr<WebSocketFrameChunk> chunk,
std::unique_ptr<WebSocketFrame>* frame) {
DCHECK(frame->get() == nullptr);
bool is_first_chunk = false;
if (chunk->header) {
DCHECK(current_frame_header_ == nullptr)
<< "Received the header for a new frame without notification that "
<< "the previous frame was complete (bug in WebSocketFrameParser?)";
is_first_chunk = true;
current_frame_header_.swap(chunk->header);
}
DCHECK(current_frame_header_) << "Unexpected header-less chunk received "
<< "(final_chunk = " << chunk->final_chunk
<< ", payload size = " << chunk->payload.size()
<< ") (bug in WebSocketFrameParser?)";
const bool is_final_chunk = chunk->final_chunk;
const WebSocketFrameHeader::OpCode opcode = current_frame_header_->opcode;
if (WebSocketFrameHeader::IsKnownControlOpCode(opcode)) {
bool protocol_error = false;
if (!current_frame_header_->final) {
DVLOG(1) << "WebSocket protocol error. Control frame, opcode=" << opcode
<< " received with FIN bit unset.";
protocol_error = true;
}
if (current_frame_header_->payload_length > kMaxControlFramePayload) {
DVLOG(1) << "WebSocket protocol error. Control frame, opcode=" << opcode
<< ", payload_length=" << current_frame_header_->payload_length
<< " exceeds maximum payload length for a control message.";
protocol_error = true;
}
if (protocol_error) {
current_frame_header_.reset();
return ERR_WS_PROTOCOL_ERROR;
}
if (!is_final_chunk) {
DVLOG(2) << "Encountered a split control frame, opcode " << opcode;
AddToIncompleteControlFrameBody(chunk->payload);
return OK;
}
if (!incomplete_control_frame_body_.empty()) {
DVLOG(2) << "Rejoining a split control frame, opcode " << opcode;
AddToIncompleteControlFrameBody(chunk->payload);
DCHECK(is_final_chunk);
DCHECK(complete_control_frame_body_.empty());
complete_control_frame_body_ = std::move(incomplete_control_frame_body_);
*frame = CreateFrame(is_final_chunk, complete_control_frame_body_);
return OK;
}
}
// Apply basic sanity checks to the |payload_length| field from the frame
// header. A check for exact equality can only be used when the whole frame
// arrives in one chunk.
DCHECK_GE(current_frame_header_->payload_length,
base::checked_cast<uint64_t>(chunk->payload.size()));
DCHECK(!is_first_chunk || !is_final_chunk ||
current_frame_header_->payload_length ==
base::checked_cast<uint64_t>(chunk->payload.size()));
// Convert the chunk to a complete frame.
*frame = CreateFrame(is_final_chunk, chunk->payload);
return OK;
}
std::unique_ptr<WebSocketFrame> WebSocketBasicStream::CreateFrame(
bool is_final_chunk,
base::span<const char> data) {
std::unique_ptr<WebSocketFrame> result_frame;
const bool is_final_chunk_in_message =
is_final_chunk && current_frame_header_->final;
const WebSocketFrameHeader::OpCode opcode = current_frame_header_->opcode;
// Empty frames convey no useful information unless they are the first frame
// (containing the type and flags) or have the "final" bit set.
if (is_final_chunk_in_message || data.size() > 0 ||
current_frame_header_->opcode !=
WebSocketFrameHeader::kOpCodeContinuation) {
result_frame = std::make_unique<WebSocketFrame>(opcode);
result_frame->header.CopyFrom(*current_frame_header_);
result_frame->header.final = is_final_chunk_in_message;
result_frame->header.payload_length = data.size();
result_frame->payload = data.data();
// Ensure that opcodes Text and Binary are only used for the first frame in
// the message. Also clear the reserved bits.
// TODO(ricea): If a future extension requires the reserved bits to be
// retained on continuation frames, make this behaviour conditional on a
// flag set at construction time.
if (!is_final_chunk && WebSocketFrameHeader::IsKnownDataOpCode(opcode)) {
current_frame_header_->opcode = WebSocketFrameHeader::kOpCodeContinuation;
current_frame_header_->reserved1 = false;
current_frame_header_->reserved2 = false;
current_frame_header_->reserved3 = false;
}
}
// Make sure that a frame header is not applied to any chunks that do not
// belong to it.
if (is_final_chunk)
current_frame_header_.reset();
return result_frame;
}
void WebSocketBasicStream::AddToIncompleteControlFrameBody(
base::span<const char> data) {
if (data.empty()) {
return;
}
incomplete_control_frame_body_.insert(incomplete_control_frame_body_.end(),
data.begin(), data.end());
// This method checks for oversize control frames above, so as long as
// the frame parser is working correctly, this won't overflow. If a bug
// does cause it to overflow, it will CHECK() in
// AddToIncompleteControlFrameBody() without writing outside the buffer.
CHECK_LE(incomplete_control_frame_body_.size(), kMaxControlFramePayload)
<< "Control frame body larger than frame header indicates; frame parser "
"bug?";
}
} // namespace net