| // Copyright (c) 2012 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/quic/quic_http_stream.h" |
| |
| #include "base/callback_helpers.h" |
| #ifdef TEMP_INSTRUMENTATION_468529 |
| #include "base/debug/alias.h" |
| #endif |
| #include "base/metrics/histogram_macros.h" |
| #include "base/strings/stringprintf.h" |
| #include "net/base/io_buffer.h" |
| #include "net/base/net_errors.h" |
| #include "net/http/http_response_headers.h" |
| #include "net/http/http_util.h" |
| #include "net/quic/quic_chromium_client_session.h" |
| #include "net/quic/quic_http_utils.h" |
| #include "net/quic/quic_reliable_client_stream.h" |
| #include "net/quic/quic_utils.h" |
| #include "net/quic/spdy_utils.h" |
| #include "net/socket/next_proto.h" |
| #include "net/spdy/spdy_frame_builder.h" |
| #include "net/spdy/spdy_framer.h" |
| #include "net/spdy/spdy_http_utils.h" |
| #include "net/ssl/ssl_info.h" |
| |
| namespace net { |
| |
| QuicHttpStream::QuicHttpStream( |
| const base::WeakPtr<QuicChromiumClientSession>& session) |
| : next_state_(STATE_NONE), |
| session_(session), |
| session_error_(OK), |
| was_handshake_confirmed_(session->IsCryptoHandshakeConfirmed()), |
| stream_(nullptr), |
| request_info_(nullptr), |
| request_body_stream_(nullptr), |
| priority_(MINIMUM_PRIORITY), |
| response_info_(nullptr), |
| response_status_(OK), |
| response_headers_received_(false), |
| closed_stream_received_bytes_(0), |
| user_buffer_len_(0), |
| weak_factory_(this) { |
| DCHECK(session_); |
| session_->AddObserver(this); |
| } |
| |
| QuicHttpStream::~QuicHttpStream() { |
| #ifdef TEMP_INSTRUMENTATION_468529 |
| liveness_ = DEAD; |
| stack_trace_ = base::debug::StackTrace(); |
| |
| // Probably not necessary, but just in case compiler tries to optimize out the |
| // writes to liveness_ and stack_trace_. |
| base::debug::Alias(&liveness_); |
| base::debug::Alias(&stack_trace_); |
| #endif |
| |
| Close(false); |
| if (session_) |
| session_->RemoveObserver(this); |
| } |
| |
| int QuicHttpStream::InitializeStream(const HttpRequestInfo* request_info, |
| RequestPriority priority, |
| const BoundNetLog& stream_net_log, |
| const CompletionCallback& callback) { |
| DCHECK(!stream_); |
| if (!session_) |
| return was_handshake_confirmed_ ? ERR_CONNECTION_CLOSED : |
| ERR_QUIC_HANDSHAKE_FAILED; |
| |
| stream_net_log.AddEvent( |
| NetLog::TYPE_HTTP_STREAM_REQUEST_BOUND_TO_QUIC_SESSION, |
| session_->net_log().source().ToEventParametersCallback()); |
| |
| if (request_info->url.SchemeIsCryptographic()) { |
| SSLInfo ssl_info; |
| bool secure_session = |
| session_->GetSSLInfo(&ssl_info) && ssl_info.cert.get(); |
| UMA_HISTOGRAM_BOOLEAN("Net.QuicSession.SecureResourceSecureSession", |
| secure_session); |
| if (!secure_session) |
| return ERR_REQUEST_FOR_SECURE_RESOURCE_OVER_INSECURE_QUIC; |
| } |
| |
| stream_net_log_ = stream_net_log; |
| request_info_ = request_info; |
| request_time_ = base::Time::Now(); |
| priority_ = priority; |
| |
| int rv = stream_request_.StartRequest( |
| session_, &stream_, base::Bind(&QuicHttpStream::OnStreamReady, |
| weak_factory_.GetWeakPtr())); |
| if (rv == ERR_IO_PENDING) { |
| callback_ = callback; |
| } else if (rv == OK) { |
| stream_->SetDelegate(this); |
| } else if (!was_handshake_confirmed_) { |
| rv = ERR_QUIC_HANDSHAKE_FAILED; |
| } |
| |
| return rv; |
| } |
| |
| void QuicHttpStream::OnStreamReady(int rv) { |
| DCHECK(rv == OK || !stream_); |
| if (rv == OK) { |
| stream_->SetDelegate(this); |
| } else if (!was_handshake_confirmed_) { |
| rv = ERR_QUIC_HANDSHAKE_FAILED; |
| } |
| |
| ResetAndReturn(&callback_).Run(rv); |
| } |
| |
| int QuicHttpStream::SendRequest(const HttpRequestHeaders& request_headers, |
| HttpResponseInfo* response, |
| const CompletionCallback& callback) { |
| CHECK(!request_body_stream_); |
| CHECK(!response_info_); |
| CHECK(!callback.is_null()); |
| CHECK(response); |
| |
| // TODO(rch): remove this once we figure out why channel ID is not being |
| // sent when it should be. |
| HostPortPair origin = HostPortPair::FromURL(request_info_->url); |
| if (origin.Equals(HostPortPair("accounts.google.com", 443)) && |
| request_headers.HasHeader(HttpRequestHeaders::kCookie)) { |
| SSLInfo ssl_info; |
| bool secure_session = |
| session_->GetSSLInfo(&ssl_info) && ssl_info.cert.get(); |
| DCHECK(secure_session); |
| UMA_HISTOGRAM_BOOLEAN("Net.QuicSession.CookieSentToAccountsOverChannelId", |
| ssl_info.channel_id_sent); |
| } |
| if (!stream_) { |
| return ERR_CONNECTION_CLOSED; |
| } |
| |
| QuicPriority priority = ConvertRequestPriorityToQuicPriority(priority_); |
| stream_->set_priority(priority); |
| // Store the serialized request headers. |
| CreateSpdyHeadersFromHttpRequest(*request_info_, request_headers, |
| GetSpdyVersion(), |
| /*direct=*/true, &request_headers_); |
| |
| // Store the request body. |
| request_body_stream_ = request_info_->upload_data_stream; |
| if (request_body_stream_) { |
| // TODO(rch): Can we be more precise about when to allocate |
| // raw_request_body_buf_. Removed the following check. DoReadRequestBody() |
| // was being called even if we didn't yet allocate raw_request_body_buf_. |
| // && (request_body_stream_->size() || |
| // request_body_stream_->is_chunked())) |
| // Use 10 packets as the body buffer size to give enough space to |
| // help ensure we don't often send out partial packets. |
| raw_request_body_buf_ = |
| new IOBufferWithSize(static_cast<size_t>(10 * kMaxPacketSize)); |
| // The request body buffer is empty at first. |
| request_body_buf_ = new DrainableIOBuffer(raw_request_body_buf_.get(), 0); |
| } |
| |
| // Store the response info. |
| response_info_ = response; |
| |
| next_state_ = STATE_SEND_HEADERS; |
| int rv = DoLoop(OK); |
| if (rv == ERR_IO_PENDING) |
| callback_ = callback; |
| |
| return rv > 0 ? OK : rv; |
| } |
| |
| UploadProgress QuicHttpStream::GetUploadProgress() const { |
| if (!request_body_stream_) |
| return UploadProgress(); |
| |
| return UploadProgress(request_body_stream_->position(), |
| request_body_stream_->size()); |
| } |
| |
| int QuicHttpStream::ReadResponseHeaders(const CompletionCallback& callback) { |
| CHECK(!callback.is_null()); |
| |
| if (stream_ == nullptr) |
| return response_status_; |
| |
| // Check if we already have the response headers. If so, return synchronously. |
| if (response_headers_received_) |
| return OK; |
| |
| // Still waiting for the response, return IO_PENDING. |
| CHECK(callback_.is_null()); |
| callback_ = callback; |
| return ERR_IO_PENDING; |
| } |
| |
| int QuicHttpStream::ReadResponseBody( |
| IOBuffer* buf, int buf_len, const CompletionCallback& callback) { |
| if (!stream_) { |
| // If the stream is already closed, there is no body to read. |
| return response_status_; |
| } |
| |
| int rv = ReadAvailableData(buf, buf_len); |
| if (rv != ERR_IO_PENDING) |
| return rv; |
| |
| CHECK(callback_.is_null()); |
| CHECK(!user_buffer_.get()); |
| CHECK_EQ(0, user_buffer_len_); |
| |
| callback_ = callback; |
| user_buffer_ = buf; |
| user_buffer_len_ = buf_len; |
| return ERR_IO_PENDING; |
| } |
| |
| void QuicHttpStream::Close(bool not_reusable) { |
| // Note: the not_reusable flag has no meaning for SPDY streams. |
| if (stream_) { |
| closed_stream_received_bytes_ = stream_->stream_bytes_read(); |
| stream_->SetDelegate(nullptr); |
| stream_->Reset(QUIC_STREAM_CANCELLED); |
| stream_ = nullptr; |
| response_status_ = was_handshake_confirmed_ ? |
| ERR_CONNECTION_CLOSED : ERR_QUIC_HANDSHAKE_FAILED; |
| } |
| } |
| |
| HttpStream* QuicHttpStream::RenewStreamForAuth() { |
| return nullptr; |
| } |
| |
| bool QuicHttpStream::IsResponseBodyComplete() const { |
| return next_state_ == STATE_OPEN && !stream_; |
| } |
| |
| bool QuicHttpStream::CanFindEndOfResponse() const { |
| return true; |
| } |
| |
| bool QuicHttpStream::IsConnectionReused() const { |
| // TODO(rch): do something smarter here. |
| return stream_ && stream_->id() > 1; |
| } |
| |
| void QuicHttpStream::SetConnectionReused() { |
| // QUIC doesn't need an indicator here. |
| } |
| |
| bool QuicHttpStream::IsConnectionReusable() const { |
| // QUIC streams aren't considered reusable. |
| return false; |
| } |
| |
| int64 QuicHttpStream::GetTotalReceivedBytes() const { |
| if (stream_) { |
| return stream_->stream_bytes_read(); |
| } |
| |
| return closed_stream_received_bytes_; |
| } |
| |
| bool QuicHttpStream::GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const { |
| // TODO(mmenke): Figure out what to do here. |
| return true; |
| } |
| |
| void QuicHttpStream::GetSSLInfo(SSLInfo* ssl_info) { |
| DCHECK(stream_); |
| session_->GetSSLInfo(ssl_info); |
| } |
| |
| void QuicHttpStream::GetSSLCertRequestInfo( |
| SSLCertRequestInfo* cert_request_info) { |
| DCHECK(stream_); |
| NOTIMPLEMENTED(); |
| } |
| |
| bool QuicHttpStream::IsSpdyHttpStream() const { |
| return false; |
| } |
| |
| void QuicHttpStream::Drain(HttpNetworkSession* session) { |
| Close(false); |
| delete this; |
| } |
| |
| void QuicHttpStream::SetPriority(RequestPriority priority) { |
| priority_ = priority; |
| } |
| |
| void QuicHttpStream::OnHeadersAvailable(const SpdyHeaderBlock& headers) { |
| int rv = ProcessResponseHeaders(headers); |
| if (rv != ERR_IO_PENDING && !callback_.is_null()) { |
| DoCallback(rv); |
| } |
| } |
| |
| void QuicHttpStream::OnDataAvailable() { |
| if (callback_.is_null()) { |
| // Data is available, but can't be delivered |
| return; |
| } |
| |
| CHECK(user_buffer_.get()); |
| CHECK_NE(0, user_buffer_len_); |
| int rv = ReadAvailableData(user_buffer_.get(), user_buffer_len_); |
| if (rv == ERR_IO_PENDING) { |
| // This was a spurrious notification. Wait for the next one. |
| return; |
| } |
| |
| CHECK(!callback_.is_null()); |
| user_buffer_ = nullptr; |
| user_buffer_len_ = 0; |
| DoCallback(rv); |
| } |
| |
| void QuicHttpStream::OnClose(QuicErrorCode error) { |
| if (error != QUIC_NO_ERROR) { |
| response_status_ = was_handshake_confirmed_ ? |
| ERR_QUIC_PROTOCOL_ERROR : ERR_QUIC_HANDSHAKE_FAILED; |
| } else if (!response_headers_received_) { |
| response_status_ = ERR_ABORTED; |
| } |
| |
| closed_stream_received_bytes_ = stream_->stream_bytes_read(); |
| stream_ = nullptr; |
| if (!callback_.is_null()) |
| DoCallback(response_status_); |
| } |
| |
| void QuicHttpStream::OnError(int error) { |
| stream_ = nullptr; |
| response_status_ = was_handshake_confirmed_ ? |
| error : ERR_QUIC_HANDSHAKE_FAILED; |
| if (!callback_.is_null()) |
| DoCallback(response_status_); |
| } |
| |
| bool QuicHttpStream::HasSendHeadersComplete() { |
| return next_state_ > STATE_SEND_HEADERS_COMPLETE; |
| } |
| |
| void QuicHttpStream::OnCryptoHandshakeConfirmed() { |
| was_handshake_confirmed_ = true; |
| } |
| |
| void QuicHttpStream::OnSessionClosed(int error) { |
| Close(false); |
| session_error_ = error; |
| session_.reset(); |
| } |
| |
| void QuicHttpStream::OnIOComplete(int rv) { |
| rv = DoLoop(rv); |
| |
| if (rv != ERR_IO_PENDING && !callback_.is_null()) { |
| DoCallback(rv); |
| } |
| } |
| |
| void QuicHttpStream::DoCallback(int rv) { |
| CHECK_NE(rv, ERR_IO_PENDING); |
| CHECK(!callback_.is_null()); |
| |
| // The client callback can do anything, including destroying this class, |
| // so any pending callback must be issued after everything else is done. |
| base::ResetAndReturn(&callback_).Run(rv); |
| } |
| |
| int QuicHttpStream::DoLoop(int rv) { |
| do { |
| CrashIfInvalid(); |
| |
| State state = next_state_; |
| next_state_ = STATE_NONE; |
| switch (state) { |
| case STATE_SEND_HEADERS: |
| CHECK_EQ(OK, rv); |
| rv = DoSendHeaders(); |
| break; |
| case STATE_SEND_HEADERS_COMPLETE: |
| rv = DoSendHeadersComplete(rv); |
| break; |
| case STATE_READ_REQUEST_BODY: |
| CHECK_EQ(OK, rv); |
| rv = DoReadRequestBody(); |
| break; |
| case STATE_READ_REQUEST_BODY_COMPLETE: |
| rv = DoReadRequestBodyComplete(rv); |
| break; |
| case STATE_SEND_BODY: |
| CHECK_EQ(OK, rv); |
| rv = DoSendBody(); |
| break; |
| case STATE_SEND_BODY_COMPLETE: |
| rv = DoSendBodyComplete(rv); |
| break; |
| case STATE_OPEN: |
| CHECK_EQ(OK, rv); |
| break; |
| default: |
| NOTREACHED() << "next_state_: " << next_state_; |
| break; |
| } |
| } while (next_state_ != STATE_NONE && next_state_ != STATE_OPEN && |
| rv != ERR_IO_PENDING); |
| |
| return rv; |
| } |
| |
| int QuicHttpStream::DoSendHeaders() { |
| if (!stream_) |
| return ERR_UNEXPECTED; |
| |
| // Log the actual request with the URL Request's net log. |
| stream_net_log_.AddEvent( |
| NetLog::TYPE_HTTP_TRANSACTION_QUIC_SEND_REQUEST_HEADERS, |
| base::Bind(&QuicRequestNetLogCallback, stream_->id(), &request_headers_, |
| priority_)); |
| // Also log to the QuicSession's net log. |
| stream_->net_log().AddEvent( |
| NetLog::TYPE_QUIC_HTTP_STREAM_SEND_REQUEST_HEADERS, |
| base::Bind(&QuicRequestNetLogCallback, stream_->id(), &request_headers_, |
| priority_)); |
| |
| bool has_upload_data = request_body_stream_ != nullptr; |
| |
| next_state_ = STATE_SEND_HEADERS_COMPLETE; |
| int rv = stream_->WriteHeaders(request_headers_, !has_upload_data, nullptr); |
| request_headers_.clear(); |
| return rv; |
| } |
| |
| int QuicHttpStream::DoSendHeadersComplete(int rv) { |
| if (rv < 0) |
| return rv; |
| |
| next_state_ = request_body_stream_ ? |
| STATE_READ_REQUEST_BODY : STATE_OPEN; |
| |
| return OK; |
| } |
| |
| int QuicHttpStream::DoReadRequestBody() { |
| next_state_ = STATE_READ_REQUEST_BODY_COMPLETE; |
| return request_body_stream_->Read( |
| raw_request_body_buf_.get(), |
| raw_request_body_buf_->size(), |
| base::Bind(&QuicHttpStream::OnIOComplete, weak_factory_.GetWeakPtr())); |
| } |
| |
| int QuicHttpStream::DoReadRequestBodyComplete(int rv) { |
| // |rv| is the result of read from the request body from the last call to |
| // DoSendBody(). |
| if (rv < 0) |
| return rv; |
| |
| request_body_buf_ = new DrainableIOBuffer(raw_request_body_buf_.get(), rv); |
| if (rv == 0) { // Reached the end. |
| DCHECK(request_body_stream_->IsEOF()); |
| } |
| |
| next_state_ = STATE_SEND_BODY; |
| return OK; |
| } |
| |
| int QuicHttpStream::DoSendBody() { |
| if (!stream_) |
| return ERR_UNEXPECTED; |
| |
| CHECK(request_body_stream_); |
| CHECK(request_body_buf_.get()); |
| const bool eof = request_body_stream_->IsEOF(); |
| int len = request_body_buf_->BytesRemaining(); |
| if (len > 0 || eof) { |
| next_state_ = STATE_SEND_BODY_COMPLETE; |
| base::StringPiece data(request_body_buf_->data(), len); |
| return stream_->WriteStreamData( |
| data, eof, |
| base::Bind(&QuicHttpStream::OnIOComplete, weak_factory_.GetWeakPtr())); |
| } |
| |
| next_state_ = STATE_OPEN; |
| return OK; |
| } |
| |
| int QuicHttpStream::DoSendBodyComplete(int rv) { |
| if (rv < 0) |
| return rv; |
| |
| request_body_buf_->DidConsume(request_body_buf_->BytesRemaining()); |
| |
| if (!request_body_stream_->IsEOF()) { |
| next_state_ = STATE_READ_REQUEST_BODY; |
| return OK; |
| } |
| |
| next_state_ = STATE_OPEN; |
| return OK; |
| } |
| |
| int QuicHttpStream::ProcessResponseHeaders(const SpdyHeaderBlock& headers) { |
| // The URLRequest logs these headers, so only log to the QuicSession's |
| // net log. |
| stream_->net_log().AddEvent( |
| NetLog::TYPE_QUIC_HTTP_STREAM_READ_RESPONSE_HEADERS, |
| base::Bind(&SpdyHeaderBlockNetLogCallback, &headers)); |
| |
| if (!SpdyHeadersToHttpResponse(headers, GetSpdyVersion(), response_info_)) { |
| DLOG(WARNING) << "Invalid headers"; |
| return ERR_QUIC_PROTOCOL_ERROR; |
| } |
| // Put the peer's IP address and port into the response. |
| IPEndPoint address = session_->peer_address(); |
| response_info_->socket_address = HostPortPair::FromIPEndPoint(address); |
| response_info_->connection_info = |
| HttpResponseInfo::CONNECTION_INFO_QUIC1_SPDY3; |
| response_info_->vary_data |
| .Init(*request_info_, *response_info_->headers.get()); |
| response_info_->was_npn_negotiated = true; |
| response_info_->npn_negotiated_protocol = "quic/1+spdy/3"; |
| response_info_->response_time = base::Time::Now(); |
| response_info_->request_time = request_time_; |
| response_headers_received_ = true; |
| |
| return OK; |
| } |
| |
| int QuicHttpStream::ReadAvailableData(IOBuffer* buf, int buf_len) { |
| int rv = stream_->Read(buf, buf_len); |
| if (stream_->IsDoneReading()) { |
| stream_->SetDelegate(nullptr); |
| stream_->OnFinRead(); |
| stream_ = nullptr; |
| } |
| return rv; |
| } |
| |
| SpdyMajorVersion QuicHttpStream::GetSpdyVersion() { |
| return SpdyUtils::GetSpdyVersionForQuicVersion(stream_->version()); |
| } |
| |
| void QuicHttpStream::CrashIfInvalid() const { |
| #ifdef TEMP_INSTRUMENTATION_468529 |
| Liveness liveness = liveness_; |
| |
| if (liveness == ALIVE) |
| return; |
| |
| // Copy relevant variables onto the stack to guarantee they will be available |
| // in minidumps, and then crash. |
| base::debug::StackTrace stack_trace = stack_trace_; |
| |
| base::debug::Alias(&liveness); |
| base::debug::Alias(&stack_trace); |
| |
| CHECK_EQ(ALIVE, liveness); |
| #endif |
| } |
| |
| } // namespace net |