Landing Recent QUIC changes until 12/18/2015 13:57 UTC

net/quic/quic_session.cc

 // 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_session.h"
 
 #include "base/stl_util.h"
+#include "base/strings/stringprintf.h"
 #include "net/quic/crypto/proof_verifier.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_flow_controller.h"
 #include "net/ssl/ssl_info.h"
 
 using base::StringPiece;
 using base::hash_map;
 using base::hash_set;
 using std::make_pair;
@@ skipping 379 matching lines @@
     return;
   }
 
   DVLOG(1) << ENDPOINT << "Received final byte offset " << final_byte_offset
            << " for stream " << stream_id;
   QuicByteCount offset_diff = final_byte_offset - it->second;
   if (flow_controller_.UpdateHighestReceivedOffset(
           flow_controller_.highest_received_byte_offset() + offset_diff)) {
     // If the final offset violates flow control, close the connection now.
     if (flow_controller_.FlowControlViolation()) {
-      connection_->SendConnectionClose(
-          QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA);
+      connection_->SendConnectionCloseWithDetails(
+          QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA,
+          "Connection level flow control violation");
       return;
     }
   }
 
   flow_controller_.AddBytesConsumed(offset_diff);
   locally_closed_streams_highest_offset_.erase(it);
   if (IsIncomingStream(stream_id)) {
     --num_locally_closed_incoming_streams_highest_offset_;
   }
 }
@@ skipping 89 matching lines @@
     kv.second->flow_controller()->UpdateReceiveWindowSize(stream_window);
   }
 }
 
 void QuicSession::OnNewStreamFlowControlWindow(QuicStreamOffset new_window) {
   if (new_window < kMinimumFlowControlSendWindow) {
     LOG(ERROR) << "Peer sent us an invalid stream flow control send window: "
                << new_window
                << ", below default: " << kMinimumFlowControlSendWindow;
     if (connection_->connected()) {
-      connection_->SendConnectionClose(QUIC_FLOW_CONTROL_INVALID_WINDOW);
+      connection_->SendConnectionCloseWithDetails(
+          QUIC_FLOW_CONTROL_INVALID_WINDOW, "New stream window too low");
     }
     return;
   }
 
   // Inform all existing streams about the new window.
   for (auto const& kv : static_stream_map_) {
     kv.second->UpdateSendWindowOffset(new_window);
   }
   for (auto const& kv : dynamic_stream_map_) {
     kv.second->UpdateSendWindowOffset(new_window);
   }
 }
 
 void QuicSession::OnNewSessionFlowControlWindow(QuicStreamOffset new_window) {
   if (new_window < kMinimumFlowControlSendWindow) {
     LOG(ERROR) << "Peer sent us an invalid session flow control send window: "
                << new_window
                << ", below default: " << kMinimumFlowControlSendWindow;
     if (connection_->connected()) {
-      connection_->SendConnectionClose(QUIC_FLOW_CONTROL_INVALID_WINDOW);
+      connection_->SendConnectionCloseWithDetails(
+          QUIC_FLOW_CONTROL_INVALID_WINDOW, "New connection window too low");
     }
     return;
   }
 
   flow_controller_.UpdateSendWindowOffset(new_window);
 }
 
 void QuicSession::OnCryptoHandshakeEvent(CryptoHandshakeEvent event) {
   switch (event) {
     // TODO(satyamshekhar): Move the logic of setting the encrypter/decrypter
@@ skipping 68 matching lines @@
 void QuicSession::StreamDraining(QuicStreamId stream_id) {
   DCHECK(ContainsKey(dynamic_stream_map_, stream_id));
   if (!ContainsKey(draining_streams_, stream_id)) {
     draining_streams_.insert(stream_id);
     if (IsIncomingStream(stream_id)) {
       ++num_draining_incoming_streams_;
     }
   }
 }
 
-void QuicSession::CloseConnection(QuicErrorCode error) {
+void QuicSession::CloseConnectionWithDetails(QuicErrorCode error,
+                                             const char* details) {
   if (connection()->connected()) {
-    connection()->SendConnectionClose(error);
+    connection()->SendConnectionCloseWithDetails(error, details);
   }
 }
 
 ReliableQuicStream* QuicSession::GetOrCreateDynamicStream(
     const QuicStreamId stream_id) {
   if (ContainsKey(static_stream_map_, stream_id)) {
     DLOG(FATAL)
         << "Attempt to call GetOrCreateDynamicStream for a static stream";
     return nullptr;
   }
 
   StreamMap::iterator it = dynamic_stream_map_.find(stream_id);
   if (it != dynamic_stream_map_.end()) {
     return it->second;
   }
 
   if (IsClosedStream(stream_id)) {
     return nullptr;
   }
 
   if (!IsIncomingStream(stream_id)) {
     // Received a frame for a locally-created stream that is not currently
     // active. This is an error.
-    CloseConnection(QUIC_INVALID_STREAM_ID);
+    CloseConnectionWithDetails(QUIC_INVALID_STREAM_ID,
+                               "Data for nonexistent stream");
     return nullptr;
   }
 
   available_streams_.erase(stream_id);
 
   if (stream_id > largest_peer_created_stream_id_) {
     // Check if the new number of available streams would cause the number of
     // available streams to exceed the limit.  Note that the peer can create
     // only alternately-numbered streams.
     size_t additional_available_streams =
         (stream_id - largest_peer_created_stream_id_) / 2 - 1;
     size_t new_num_available_streams =
         GetNumAvailableStreams() + additional_available_streams;
     if (new_num_available_streams > get_max_available_streams()) {
       DVLOG(1) << "Failed to create a new incoming stream with id:" << stream_id
                << ".  There are already " << GetNumAvailableStreams()
                << " streams available, which would become "
                << new_num_available_streams << ", which exceeds the limit "
                << get_max_available_streams() << ".";
-      CloseConnection(QUIC_TOO_MANY_AVAILABLE_STREAMS);
+      CloseConnectionWithDetails(
+          QUIC_TOO_MANY_AVAILABLE_STREAMS,
+          base::StringPrintf(
+              "%lu above %lu",
+              static_cast<unsigned long>(new_num_available_streams),
+              static_cast<unsigned long>(get_max_available_streams()))
+              .c_str());
       return nullptr;
     }
     for (QuicStreamId id = largest_peer_created_stream_id_ + 2; id < stream_id;
          id += 2) {
       available_streams_.insert(id);
     }
     largest_peer_created_stream_id_ = stream_id;
   }
   // Check if the new number of open streams would cause the number of
   // open streams to exceed the limit.
   size_t num_current_open_streams =
       FLAGS_quic_distinguish_incoming_outgoing_streams
           ? GetNumOpenIncomingStreams()
           : dynamic_stream_map_.size() - draining_streams_.size() +
                 locally_closed_streams_highest_offset_.size();
   if (num_current_open_streams >= get_max_open_streams()) {
     if (connection()->version() <= QUIC_VERSION_27) {
-      CloseConnection(QUIC_TOO_MANY_OPEN_STREAMS);
+      CloseConnectionWithDetails(QUIC_TOO_MANY_OPEN_STREAMS,
+                                 "Old style stream rejection");
     } else {
       // Refuse to open the stream.
       SendRstStream(stream_id, QUIC_REFUSED_STREAM, 0);
     }
     return nullptr;
   }
   ReliableQuicStream* stream = CreateIncomingDynamicStream(stream_id);
   if (stream == nullptr) {
     return nullptr;
   }
@@ skipping 108 matching lines @@
     }
   }
   return false;
 }
 
 bool QuicSession::IsIncomingStream(QuicStreamId id) const {
   return id % 2 != next_outgoing_stream_id_ % 2;
 }
 
 }  // namespace net