Landing Recent QUIC changes until 10:38 AM, Oct 17, 2016 UTC-4

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 261 matching lines @@
                                  current_client_address_, *current_packet_);
     return false;
   }
 
   if (FLAGS_quic_buffer_packets_after_chlo &&
       buffered_packets_.HasChloForConnection(connection_id)) {
     BufferEarlyPacket(connection_id);
     return false;
   }
 
+  // Check if we are buffering packets for this connection ID
+  if (FLAGS_enable_async_get_proof &&
+      (temporarily_buffered_connections_.find(connection_id) !=
+       temporarily_buffered_connections_.end())) {
+    // This packet was received while the a CHLO for the same connection ID was
+    // being processed.  Buffer it.
+    BufferEarlyPacket(connection_id);
+    return false;
+  }
+
   if (!OnUnauthenticatedUnknownPublicHeader(header)) {
     return false;
   }
 
   // If the packet is a public reset for a connection ID that is not active,
   // there is nothing we must do or can do.
   if (header.reset_flag) {
     return false;
   }
 
@@ skipping 59 matching lines @@
 void QuicDispatcher::ProcessUnauthenticatedHeaderFate(
     QuicPacketFate fate,
     QuicConnectionId connection_id,
     QuicPacketNumber packet_number) {
   switch (fate) {
     case kFateProcess: {
       ProcessChlo();
       break;
     }
     case kFateTimeWait:
-      // MaybeRejectStatelessly might have already added the connection to
-      // time wait, in which case it should not be added again.
+      // MaybeRejectStatelessly or OnExpiredPackets might have already added the
+      // connection to time wait, in which case it should not be added again.
       if (!FLAGS_quic_use_cheap_stateless_rejects ||
           !time_wait_list_manager_->IsConnectionIdInTimeWait(connection_id)) {
         // Add this connection_id to the time-wait state, to safely reject
         // future packets.
         DVLOG(1) << "Adding connection ID " << connection_id
                  << "to time-wait list.";
         time_wait_list_manager_->AddConnectionIdToTimeWait(
             connection_id, framer_.version(),
             /*connection_rejected_statelessly=*/false, nullptr);
       }
       DCHECK(time_wait_list_manager_->IsConnectionIdInTimeWait(connection_id));
       time_wait_list_manager_->ProcessPacket(
           current_server_address_, current_client_address_, connection_id,
           packet_number, *current_packet_);
+
+      if (FLAGS_enable_async_get_proof) {
+        // Any packets which were buffered while the stateless rejector logic
+        // was running should be discarded.  Do not inform the time wait list
+        // manager, which should already have a made a decision about sending a
+        // reject based on the CHLO alone.
+        buffered_packets_.DiscardPackets(connection_id);
+      }
+
       break;
     case kFateBuffer:
-      // This packet is a non-CHLO packet which has arrived out of order.
-      // Buffer it.
+      // This packet is a non-CHLO packet which has arrived before the
+      // corresponding CHLO, *or* this packet was received while the
+      // corresponding CHLO was being processed.  Buffer it.
       BufferEarlyPacket(connection_id);
       break;
     case kFateDrop:
       // Do nothing with the packet.
       break;
   }
 }
 
 QuicDispatcher::QuicPacketFate QuicDispatcher::ValidityChecks(
     const QuicPacketHeader& header) {
@@ skipping 392 matching lines @@
   return true;
 }
 
 class StatelessRejectorProcessDoneCallback
     : public StatelessRejector::ProcessDoneCallback {
  public:
   StatelessRejectorProcessDoneCallback(QuicDispatcher* dispatcher,
                                        QuicPacketNumber packet_number,
                                        QuicVersion first_version)
       : dispatcher_(dispatcher),
+        current_client_address_(dispatcher->current_client_address_),
+        current_server_address_(dispatcher->current_server_address_),
+        current_packet_(
+            dispatcher->current_packet_->Clone()),  // Note: copies the packet
         packet_number_(packet_number),
         first_version_(first_version) {}
 
   void Run(std::unique_ptr<StatelessRejector> rejector) override {
-    dispatcher_->OnStatelessRejectorProcessDone(std::move(rejector),
-                                                packet_number_, first_version_);
+    dispatcher_->OnStatelessRejectorProcessDone(
+        std::move(rejector), current_client_address_, current_server_address_,
+        std::move(current_packet_), packet_number_, first_version_);
   }
 
  private:
   QuicDispatcher* dispatcher_;
+  IPEndPoint current_client_address_;
+  IPEndPoint current_server_address_;
+  std::unique_ptr<QuicReceivedPacket> current_packet_;
   QuicPacketNumber packet_number_;
   QuicVersion first_version_;
 };
 
 void QuicDispatcher::MaybeRejectStatelessly(QuicConnectionId connection_id,
                                             const QuicPacketHeader& header) {
   // TODO(rch): This logic should probably live completely inside the rejector.
   if (!FLAGS_quic_use_cheap_stateless_rejects ||
       !FLAGS_enable_quic_stateless_reject_support ||
       header.public_header.versions.front() <= QUIC_VERSION_32 ||
@@ skipping 41 matching lines @@
     StatelessConnectionTerminator terminator(connection_id, &framer_, helper(),
                                              time_wait_list_manager_.get());
     terminator.CloseConnection(QUIC_HANDSHAKE_FAILED,
                                validator.error_details());
     OnConnectionClosedStatelessly(QUIC_HANDSHAKE_FAILED);
     ProcessUnauthenticatedHeaderFate(kFateTimeWait, connection_id,
                                      header.packet_number);
     return;
   }
 
+  // If we were able to make a decision about this CHLO based purely on the
+  // information available in OnChlo, just invoke the done callback immediately.
+  if (rejector->state() != StatelessRejector::UNKNOWN) {
+    ProcessStatelessRejectorState(std::move(rejector), header.packet_number,
+                                  header.public_header.versions.front());
+    return;
+  }
+
+  // Insert into set of connection IDs to buffer
+  if (FLAGS_enable_async_get_proof) {
+    const bool ok =
+        temporarily_buffered_connections_.insert(connection_id).second;
+    QUIC_BUG_IF(!ok)
+        << "Processing multiple stateless rejections for connection ID "
+        << connection_id;
+  }
+
   // Continue stateless rejector processing
   std::unique_ptr<StatelessRejectorProcessDoneCallback> cb(
       new StatelessRejectorProcessDoneCallback(
           this, header.packet_number, header.public_header.versions.front()));
   StatelessRejector::Process(std::move(rejector), std::move(cb));
 }
 
 void QuicDispatcher::OnStatelessRejectorProcessDone(
     std::unique_ptr<StatelessRejector> rejector,
+    const IPEndPoint& current_client_address,
+    const IPEndPoint& current_server_address,
+    std::unique_ptr<QuicReceivedPacket> current_packet,
+    QuicPacketNumber packet_number,
+    QuicVersion first_version) {
+  if (FLAGS_enable_async_get_proof) {
+    // Stop buffering packets on this connection
+    const auto num_erased =
+        temporarily_buffered_connections_.erase(rejector->connection_id());
+    QUIC_BUG_IF(num_erased != 1) << "Completing stateless rejection logic for "
+                                    "non-buffered connection ID "
+                                 << rejector->connection_id();
+
+    // If this connection has gone into time-wait during the async processing,
+    // don't proceed.
+    if (time_wait_list_manager_->IsConnectionIdInTimeWait(
+            rejector->connection_id())) {
+      time_wait_list_manager_->ProcessPacket(
+          current_server_address, current_client_address,
+          rejector->connection_id(), packet_number, *current_packet);
+      return;
+    }
+  }
+
+  // Reset current_* to correspond to the packet which initiated the stateless
+  // reject logic.
+  current_client_address_ = current_client_address;
+  current_server_address_ = current_server_address;
+  current_packet_ = current_packet.get();
+  current_connection_id_ = rejector->connection_id();
+
+  ProcessStatelessRejectorState(std::move(rejector), packet_number,
+                                first_version);
+}
+
+void QuicDispatcher::ProcessStatelessRejectorState(
+    std::unique_ptr<StatelessRejector> rejector,
     QuicPacketNumber packet_number,
     QuicVersion first_version) {
   QuicPacketFate fate;
   switch (rejector->state()) {
     case StatelessRejector::FAILED: {
       // There was an error processing the client hello.
       StatelessConnectionTerminator terminator(rejector->connection_id(),
                                                &framer_, helper(),
                                                time_wait_list_manager_.get());
       terminator.CloseConnection(rejector->error(), rejector->error_details());
@@ skipping 39 matching lines @@
 void QuicDispatcher::DeliverPacketsToSession(
     const std::list<BufferedPacket>& packets,
     QuicServerSessionBase* session) {
   for (const BufferedPacket& packet : packets) {
     session->ProcessUdpPacket(packet.server_address, packet.client_address,
                               *(packet.packet));
   }
 }
 
 }  // namespace net