1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #include "net/quic/quic_http_stream.h"
7 #include "base/callback_helpers.h"
8 #include "base/metrics/histogram.h"
9 #include "base/strings/stringprintf.h"
10 #include "net/base/io_buffer.h"
11 #include "net/base/net_errors.h"
12 #include "net/http/http_response_headers.h"
13 #include "net/http/http_util.h"
14 #include "net/quic/quic_client_session.h"
15 #include "net/quic/quic_http_utils.h"
16 #include "net/quic/quic_reliable_client_stream.h"
17 #include "net/quic/quic_utils.h"
18 #include "net/socket/next_proto.h"
19 #include "net/spdy/spdy_frame_builder.h"
20 #include "net/spdy/spdy_framer.h"
21 #include "net/spdy/spdy_http_utils.h"
22 #include "net/ssl/ssl_info.h"
26 static const size_t kHeaderBufInitialSize = 4096;
28 QuicHttpStream::QuicHttpStream(const base::WeakPtr<QuicClientSession>& session)
29 : next_state_(STATE_NONE),
32 was_handshake_confirmed_(session->IsCryptoHandshakeConfirmed()),
35 request_body_stream_(NULL),
36 priority_(MINIMUM_PRIORITY),
39 response_headers_received_(false),
40 read_buf_(new GrowableIOBuffer()),
41 closed_stream_received_bytes_(0),
45 session_->AddObserver(this);
48 QuicHttpStream::~QuicHttpStream() {
51 session_->RemoveObserver(this);
54 int QuicHttpStream::InitializeStream(const HttpRequestInfo* request_info,
55 RequestPriority priority,
56 const BoundNetLog& stream_net_log,
57 const CompletionCallback& callback) {
60 return was_handshake_confirmed_ ? ERR_CONNECTION_CLOSED :
61 ERR_QUIC_HANDSHAKE_FAILED;
63 if (request_info->url.SchemeIsSecure()) {
65 bool secure_session = session_->GetSSLInfo(&ssl_info) && ssl_info.cert;
66 UMA_HISTOGRAM_BOOLEAN("Net.QuicSession.SecureResourceSecureSession",
69 return ERR_REQUEST_FOR_SECURE_RESOURCE_OVER_INSECURE_QUIC;
72 stream_net_log_ = stream_net_log;
73 request_info_ = request_info;
74 request_time_ = base::Time::Now();
77 int rv = stream_request_.StartRequest(
78 session_, &stream_, base::Bind(&QuicHttpStream::OnStreamReady,
79 weak_factory_.GetWeakPtr()));
80 if (rv == ERR_IO_PENDING) {
82 } else if (rv == OK) {
83 stream_->SetDelegate(this);
84 } else if (!was_handshake_confirmed_) {
85 rv = ERR_QUIC_HANDSHAKE_FAILED;
91 void QuicHttpStream::OnStreamReady(int rv) {
92 DCHECK(rv == OK || !stream_);
94 stream_->SetDelegate(this);
95 } else if (!was_handshake_confirmed_) {
96 rv = ERR_QUIC_HANDSHAKE_FAILED;
99 ResetAndReturn(&callback_).Run(rv);
102 int QuicHttpStream::SendRequest(const HttpRequestHeaders& request_headers,
103 HttpResponseInfo* response,
104 const CompletionCallback& callback) {
106 CHECK(!request_body_stream_);
107 CHECK(!response_info_);
108 CHECK(!callback.is_null());
111 QuicPriority priority = ConvertRequestPriorityToQuicPriority(priority_);
112 stream_->set_priority(priority);
113 // Store the serialized request headers.
114 CreateSpdyHeadersFromHttpRequest(*request_info_, request_headers,
115 SPDY3, /*direct=*/true, &request_headers_);
117 // Store the request body.
118 request_body_stream_ = request_info_->upload_data_stream;
119 if (request_body_stream_) {
120 // TODO(rch): Can we be more precise about when to allocate
121 // raw_request_body_buf_. Removed the following check. DoReadRequestBody()
122 // was being called even if we didn't yet allocate raw_request_body_buf_.
123 // && (request_body_stream_->size() ||
124 // request_body_stream_->is_chunked()))
125 // Use 10 packets as the body buffer size to give enough space to
126 // help ensure we don't often send out partial packets.
127 raw_request_body_buf_ = new IOBufferWithSize(10 * kMaxPacketSize);
128 // The request body buffer is empty at first.
129 request_body_buf_ = new DrainableIOBuffer(raw_request_body_buf_.get(), 0);
132 // Store the response info.
133 response_info_ = response;
135 next_state_ = STATE_SEND_HEADERS;
137 if (rv == ERR_IO_PENDING)
138 callback_ = callback;
140 return rv > 0 ? OK : rv;
143 UploadProgress QuicHttpStream::GetUploadProgress() const {
144 if (!request_body_stream_)
145 return UploadProgress();
147 return UploadProgress(request_body_stream_->position(),
148 request_body_stream_->size());
151 int QuicHttpStream::ReadResponseHeaders(const CompletionCallback& callback) {
152 CHECK(!callback.is_null());
155 return response_status_;
157 // Check if we already have the response headers. If so, return synchronously.
158 if (response_headers_received_)
161 // Still waiting for the response, return IO_PENDING.
162 CHECK(callback_.is_null());
163 callback_ = callback;
164 return ERR_IO_PENDING;
167 int QuicHttpStream::ReadResponseBody(
168 IOBuffer* buf, int buf_len, const CompletionCallback& callback) {
171 CHECK(!callback.is_null());
173 // If we have data buffered, complete the IO immediately.
174 if (!response_body_.empty()) {
176 while (!response_body_.empty() && buf_len > 0) {
177 scoped_refptr<IOBufferWithSize> data = response_body_.front();
178 const int bytes_to_copy = std::min(buf_len, data->size());
179 memcpy(&(buf->data()[bytes_read]), data->data(), bytes_to_copy);
180 buf_len -= bytes_to_copy;
181 if (bytes_to_copy == data->size()) {
182 response_body_.pop_front();
184 const int bytes_remaining = data->size() - bytes_to_copy;
185 IOBufferWithSize* new_buffer = new IOBufferWithSize(bytes_remaining);
186 memcpy(new_buffer->data(), &(data->data()[bytes_to_copy]),
188 response_body_.pop_front();
189 response_body_.push_front(make_scoped_refptr(new_buffer));
191 bytes_read += bytes_to_copy;
197 // If the stream is already closed, there is no body to read.
198 return response_status_;
201 CHECK(callback_.is_null());
202 CHECK(!user_buffer_.get());
203 CHECK_EQ(0, user_buffer_len_);
205 callback_ = callback;
207 user_buffer_len_ = buf_len;
208 return ERR_IO_PENDING;
211 void QuicHttpStream::Close(bool not_reusable) {
212 // Note: the not_reusable flag has no meaning for SPDY streams.
214 closed_stream_received_bytes_ = stream_->stream_bytes_read();
215 stream_->SetDelegate(NULL);
216 stream_->Reset(QUIC_STREAM_CANCELLED);
221 HttpStream* QuicHttpStream::RenewStreamForAuth() {
225 bool QuicHttpStream::IsResponseBodyComplete() const {
226 return next_state_ == STATE_OPEN && !stream_;
229 bool QuicHttpStream::CanFindEndOfResponse() const {
233 bool QuicHttpStream::IsConnectionReused() const {
234 // TODO(rch): do something smarter here.
235 return stream_ && stream_->id() > 1;
238 void QuicHttpStream::SetConnectionReused() {
239 // QUIC doesn't need an indicator here.
242 bool QuicHttpStream::IsConnectionReusable() const {
243 // QUIC streams aren't considered reusable.
247 int64 QuicHttpStream::GetTotalReceivedBytes() const {
249 return stream_->stream_bytes_read();
252 return closed_stream_received_bytes_;
255 bool QuicHttpStream::GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const {
256 // TODO(mmenke): Figure out what to do here.
260 void QuicHttpStream::GetSSLInfo(SSLInfo* ssl_info) {
262 stream_->GetSSLInfo(ssl_info);
265 void QuicHttpStream::GetSSLCertRequestInfo(
266 SSLCertRequestInfo* cert_request_info) {
271 bool QuicHttpStream::IsSpdyHttpStream() const {
275 void QuicHttpStream::Drain(HttpNetworkSession* session) {
280 void QuicHttpStream::SetPriority(RequestPriority priority) {
281 priority_ = priority;
284 int QuicHttpStream::OnDataReceived(const char* data, int length) {
285 DCHECK_NE(0, length);
286 // Are we still reading the response headers.
287 if (!response_headers_received_) {
288 // Grow the read buffer if necessary.
289 if (read_buf_->RemainingCapacity() < length) {
290 size_t additional_capacity = length - read_buf_->RemainingCapacity();
291 if (additional_capacity < kHeaderBufInitialSize)
292 additional_capacity = kHeaderBufInitialSize;
293 read_buf_->SetCapacity(read_buf_->capacity() + additional_capacity);
295 memcpy(read_buf_->data(), data, length);
296 read_buf_->set_offset(read_buf_->offset() + length);
297 int rv = ParseResponseHeaders();
298 if (rv != ERR_IO_PENDING && !callback_.is_null()) {
304 if (callback_.is_null()) {
305 BufferResponseBody(data, length);
309 if (length <= user_buffer_len_) {
310 memcpy(user_buffer_->data(), data, length);
312 memcpy(user_buffer_->data(), data, user_buffer_len_);
313 int delta = length - user_buffer_len_;
314 BufferResponseBody(data + user_buffer_len_, delta);
315 length = user_buffer_len_;
319 user_buffer_len_ = 0;
324 void QuicHttpStream::OnClose(QuicErrorCode error) {
325 if (error != QUIC_NO_ERROR) {
326 response_status_ = was_handshake_confirmed_ ?
327 ERR_QUIC_PROTOCOL_ERROR : ERR_QUIC_HANDSHAKE_FAILED;
328 } else if (!response_headers_received_) {
329 response_status_ = ERR_ABORTED;
332 closed_stream_received_bytes_ = stream_->stream_bytes_read();
334 if (!callback_.is_null())
335 DoCallback(response_status_);
338 void QuicHttpStream::OnError(int error) {
340 response_status_ = was_handshake_confirmed_ ?
341 error : ERR_QUIC_HANDSHAKE_FAILED;
342 if (!callback_.is_null())
343 DoCallback(response_status_);
346 bool QuicHttpStream::HasSendHeadersComplete() {
347 return next_state_ > STATE_SEND_HEADERS_COMPLETE;
350 void QuicHttpStream::OnCryptoHandshakeConfirmed() {
351 was_handshake_confirmed_ = true;
354 void QuicHttpStream::OnSessionClosed(int error) {
355 session_error_ = error;
359 void QuicHttpStream::OnIOComplete(int rv) {
362 if (rv != ERR_IO_PENDING && !callback_.is_null()) {
367 void QuicHttpStream::DoCallback(int rv) {
368 CHECK_NE(rv, ERR_IO_PENDING);
369 CHECK(!callback_.is_null());
371 // The client callback can do anything, including destroying this class,
372 // so any pending callback must be issued after everything else is done.
373 base::ResetAndReturn(&callback_).Run(rv);
376 int QuicHttpStream::DoLoop(int rv) {
378 State state = next_state_;
379 next_state_ = STATE_NONE;
381 case STATE_SEND_HEADERS:
383 rv = DoSendHeaders();
385 case STATE_SEND_HEADERS_COMPLETE:
386 rv = DoSendHeadersComplete(rv);
388 case STATE_READ_REQUEST_BODY:
390 rv = DoReadRequestBody();
392 case STATE_READ_REQUEST_BODY_COMPLETE:
393 rv = DoReadRequestBodyComplete(rv);
395 case STATE_SEND_BODY:
399 case STATE_SEND_BODY_COMPLETE:
400 rv = DoSendBodyComplete(rv);
406 NOTREACHED() << "next_state_: " << next_state_;
409 } while (next_state_ != STATE_NONE && next_state_ != STATE_OPEN &&
410 rv != ERR_IO_PENDING);
415 int QuicHttpStream::DoSendHeaders() {
417 return ERR_UNEXPECTED;
419 // Log the actual request with the URL Request's net log.
420 stream_net_log_.AddEvent(
421 NetLog::TYPE_HTTP_TRANSACTION_QUIC_SEND_REQUEST_HEADERS,
422 base::Bind(&QuicRequestNetLogCallback, stream_->id(), &request_headers_,
424 // Also log to the QuicSession's net log.
425 stream_->net_log().AddEvent(
426 NetLog::TYPE_QUIC_HTTP_STREAM_SEND_REQUEST_HEADERS,
427 base::Bind(&QuicRequestNetLogCallback, stream_->id(), &request_headers_,
430 bool has_upload_data = request_body_stream_ != NULL;
432 next_state_ = STATE_SEND_HEADERS_COMPLETE;
433 int rv = stream_->WriteHeaders(request_headers_, !has_upload_data, NULL);
434 request_headers_.clear();
438 int QuicHttpStream::DoSendHeadersComplete(int rv) {
442 next_state_ = request_body_stream_ ?
443 STATE_READ_REQUEST_BODY : STATE_OPEN;
448 int QuicHttpStream::DoReadRequestBody() {
449 next_state_ = STATE_READ_REQUEST_BODY_COMPLETE;
450 return request_body_stream_->Read(
451 raw_request_body_buf_.get(),
452 raw_request_body_buf_->size(),
453 base::Bind(&QuicHttpStream::OnIOComplete, weak_factory_.GetWeakPtr()));
456 int QuicHttpStream::DoReadRequestBodyComplete(int rv) {
457 // |rv| is the result of read from the request body from the last call to
462 request_body_buf_ = new DrainableIOBuffer(raw_request_body_buf_.get(), rv);
463 if (rv == 0) { // Reached the end.
464 DCHECK(request_body_stream_->IsEOF());
467 next_state_ = STATE_SEND_BODY;
471 int QuicHttpStream::DoSendBody() {
473 return ERR_UNEXPECTED;
475 CHECK(request_body_stream_);
476 CHECK(request_body_buf_.get());
477 const bool eof = request_body_stream_->IsEOF();
478 int len = request_body_buf_->BytesRemaining();
479 if (len > 0 || eof) {
480 next_state_ = STATE_SEND_BODY_COMPLETE;
481 base::StringPiece data(request_body_buf_->data(), len);
482 return stream_->WriteStreamData(
484 base::Bind(&QuicHttpStream::OnIOComplete, weak_factory_.GetWeakPtr()));
487 next_state_ = STATE_OPEN;
491 int QuicHttpStream::DoSendBodyComplete(int rv) {
495 request_body_buf_->DidConsume(request_body_buf_->BytesRemaining());
497 if (!request_body_stream_->IsEOF()) {
498 next_state_ = STATE_READ_REQUEST_BODY;
502 next_state_ = STATE_OPEN;
506 int QuicHttpStream::ParseResponseHeaders() {
507 size_t read_buf_len = static_cast<size_t>(read_buf_->offset());
508 SpdyFramer framer(SPDY3);
509 SpdyHeaderBlock headers;
510 char* data = read_buf_->StartOfBuffer();
511 size_t len = framer.ParseHeaderBlockInBuffer(data, read_buf_->offset(),
515 return ERR_IO_PENDING;
518 // Save the remaining received data.
519 size_t delta = read_buf_len - len;
521 BufferResponseBody(data + len, delta);
524 // The URLRequest logs these headers, so only log to the QuicSession's
526 stream_->net_log().AddEvent(
527 NetLog::TYPE_QUIC_HTTP_STREAM_READ_RESPONSE_HEADERS,
528 base::Bind(&SpdyHeaderBlockNetLogCallback, &headers));
530 if (!SpdyHeadersToHttpResponse(headers, SPDY3, response_info_)) {
531 DLOG(WARNING) << "Invalid headers";
532 return ERR_QUIC_PROTOCOL_ERROR;
534 // Put the peer's IP address and port into the response.
535 IPEndPoint address = stream_->GetPeerAddress();
536 response_info_->socket_address = HostPortPair::FromIPEndPoint(address);
537 response_info_->connection_info =
538 HttpResponseInfo::CONNECTION_INFO_QUIC1_SPDY3;
539 response_info_->vary_data
540 .Init(*request_info_, *response_info_->headers.get());
541 response_info_->was_npn_negotiated = true;
542 response_info_->npn_negotiated_protocol = "quic/1+spdy/3";
543 response_info_->response_time = base::Time::Now();
544 response_info_->request_time = request_time_;
545 response_headers_received_ = true;
550 void QuicHttpStream::BufferResponseBody(const char* data, int length) {
553 IOBufferWithSize* io_buffer = new IOBufferWithSize(length);
554 memcpy(io_buffer->data(), data, length);
555 response_body_.push_back(make_scoped_refptr(io_buffer));