relnote: Make QUIC version negotiation stateless. The QUIC dispatcher

net/tools/quic/quic_dispatcher.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/tools/quic/quic_dispatcher.h"
 
 #include <utility>
 
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
@@ skipping 72 matching lines @@
   // ProcessPacket will cause the packet to be dispatched in
   // OnUnauthenticatedPublicHeader, or sent to the time wait list manager
   // in OnUnauthenticatedHeader.
   framer_.ProcessPacket(packet);
   // TODO(rjshade): Return a status describing if/why a packet was dropped,
   //                and log somehow.  Maybe expose as a varz.
 }
 
 bool QuicDispatcher::OnUnauthenticatedPublicHeader(
     const QuicPacketPublicHeader& header) {
+  current_connection_id_ = header.connection_id;
+
   // Port zero is only allowed for unidirectional UDP, so is disallowed by QUIC.
   // Given that we can't even send a reply rejecting the packet, just drop the
   // packet.
   if (current_client_address_.port() == 0) {
     return false;
   }
 
   // Stopgap test: The code does not construct full-length connection IDs
   // correctly from truncated connection ID fields.  Prevent this from causing
   // the connection ID lookup to error by dropping any packet with a short
@@ skipping 27 matching lines @@
   // The packet has an unknown connection ID.
 
   // Unless the packet provides a version, assume that we can continue
   // processing using our preferred version.
   QuicVersion version = supported_versions_.front();
   if (header.version_flag) {
     QuicVersion packet_version = header.versions.front();
     if (framer_.IsSupportedVersion(packet_version)) {
       version = packet_version;
     } else {
-      // Packets set to be processed but having an unsupported version will
-      // cause a connection to be created.  The connection will handle
-      // sending a version negotiation packet.
-      // TODO(ianswett): This will malfunction if the full header of the packet
-      // causes a parsing error when parsed using the server's preferred
-      // version.
+      if (FLAGS_quic_stateless_version_negotiation) {
+        DVLOG(1) << "Version mismatch, connection ID " << connection_id;
+        // Since the version is not supported, send a version negotiation
+        // packet and stop processing the current packet.
+        time_wait_list_manager()->SendVersionNegotiationPacket(
+            connection_id, supported_versions_, current_server_address_,
+            current_client_address_);
+        return false;
+      } else {
+        // Packets set to be processed but having an unsupported version will
+        // cause a connection to be created.  The connection will handle
+        // sending a version negotiation packet.
+        // TODO(ianswett): This will malfunction if the full header of the
+        // packet causes a parsing error when parsed using the server's
+        // preferred version.
+      }
     }
   }
   // Set the framer's version and continue processing.
   framer_.set_version(version);
   return true;
 }
 
 bool QuicDispatcher::OnUnauthenticatedHeader(const QuicPacketHeader& header) {
   QuicConnectionId connection_id = header.public_header.connection_id;
 
@@ skipping 173 matching lines @@
 void QuicDispatcher::OnPacket() {}
 
 void QuicDispatcher::OnError(QuicFramer* framer) {
   QuicErrorCode error = framer->error();
   SetLastError(error);
   DVLOG(1) << QuicUtils::ErrorToString(error);
 }
 
 bool QuicDispatcher::OnProtocolVersionMismatch(
     QuicVersion /*received_version*/) {
+  if (FLAGS_quic_stateless_version_negotiation) {
+    QUIC_BUG_IF(!time_wait_list_manager_->IsConnectionIdInTimeWait(
+        current_connection_id_));
+  }
+
   // Keep processing after protocol mismatch - this will be dealt with by the
   // time wait list or connection that we will create.
   return true;
 }
 
 void QuicDispatcher::OnPublicResetPacket(
     const QuicPublicResetPacket& /*packet*/) {
   DCHECK(false);
 }
 
@@ skipping 122 matching lines @@
 
 QuicPacketWriter* QuicDispatcher::CreatePerConnectionWriter() {
   return new QuicPerConnectionPacketWriter(writer_.get());
 }
 
 void QuicDispatcher::SetLastError(QuicErrorCode error) {
   last_error_ = error;
 }
 
 }  // namespace net