Landing Recent QUIC changes until 2016-07-02 02:45 UTC

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 182 matching lines @@
     std::unique_ptr<QuicAlarmFactory> alarm_factory)
     : config_(config),
       crypto_config_(crypto_config),
       compressed_certs_cache_(
           QuicCompressedCertsCache::kQuicCompressedCertsCacheSize),
       helper_(std::move(helper)),
       session_helper_(std::move(session_helper)),
       alarm_factory_(std::move(alarm_factory)),
       delete_sessions_alarm_(
           alarm_factory_->CreateAlarm(new DeleteSessionsAlarm(this))),
+      buffered_packets_(this, helper_->GetClock(), alarm_factory_.get()),
       supported_versions_(supported_versions),
       disable_quic_pre_30_(FLAGS_quic_disable_pre_30),
       allowed_supported_versions_(supported_versions),
       current_packet_(nullptr),
       framer_(supported_versions,
               /*unused*/ QuicTime::Zero(),
               Perspective::IS_SERVER),
       last_error_(QUIC_NO_ERROR) {
   framer_.set_visitor(this);
 }
@@ skipping 40 matching lines @@
   // connection ID.
   if (header.connection_id_length != PACKET_8BYTE_CONNECTION_ID) {
     return false;
   }
 
   // Packets with connection IDs for active connections are processed
   // immediately.
   QuicConnectionId connection_id = header.connection_id;
   SessionMap::iterator it = session_map_.find(connection_id);
   if (it != session_map_.end()) {
+    DCHECK(!buffered_packets_.HasBufferedPackets(connection_id));
     it->second->ProcessUdpPacket(current_server_address_,
                                  current_client_address_, *current_packet_);
     return false;
   }
 
   if (!OnUnauthenticatedUnknownPublicHeader(header)) {
     return false;
   }
 
   // If the packet is a public reset for a connection ID that is not active,
@@ skipping 54 matching lines @@
   }
   switch (fate) {
     case kFateProcess: {
       // Create a session and process the packet.
       QuicServerSessionBase* session =
           CreateQuicSession(connection_id, current_client_address_);
       DVLOG(1) << "Created new session for " << connection_id;
       session_map_.insert(std::make_pair(connection_id, session));
       session->ProcessUdpPacket(current_server_address_,
                                 current_client_address_, *current_packet_);
+      std::list<QuicBufferedPacketStore::BufferedPacket> packets =
+          buffered_packets_.DeliverPackets(connection_id);
+      for (const auto& packet : packets) {
+        SessionMap::iterator it = session_map_.find(connection_id);
+        if (it == session_map_.end()) {
+          break;
+        }
+        it->second->ProcessUdpPacket(packet.server_address,
+                                     packet.client_address, *packet.packet);
+      }
       break;
     }
     case kFateTimeWait:
       // MaybeRejectStatelessly 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(
               header.public_header.connection_id)) {
         // Add this connection_id to the time-wait state, to safely reject
         // future packets.
@@ skipping 240 matching lines @@
 
 bool QuicDispatcher::OnPathCloseFrame(const QuicPathCloseFrame& frame) {
   DCHECK(false);
   return false;
 }
 
 void QuicDispatcher::OnPacketComplete() {
   DCHECK(false);
 }
 
+void QuicDispatcher::OnExpiredPackets(
+    QuicConnectionId connection_id,
+    QuicBufferedPacketStore::BufferedPacketList early_arrived_packets) {}
+
 QuicServerSessionBase* QuicDispatcher::CreateQuicSession(
     QuicConnectionId connection_id,
     const IPEndPoint& client_address) {
   // The QuicServerSessionBase takes ownership of |connection| below.
   QuicConnection* connection = new QuicConnection(
       connection_id, client_address, helper_.get(), alarm_factory_.get(),
       CreatePerConnectionWriter(),
       /* owns_writer= */ true, Perspective::IS_SERVER, GetSupportedVersions());
 
   QuicServerSessionBase* session = new QuicSimpleServerSession(
@@ skipping 59 matching lines @@
 
   StatelessRejector rejector(header.public_header.versions.front(),
                              supported_versions_, crypto_config_,
                              &compressed_certs_cache_, helper()->GetClock(),
                              helper()->GetRandomGenerator(),
                              current_client_address_, current_server_address_);
   ChloValidator validator(session_helper_.get(), current_server_address_,
                           &rejector);
   if (!ChloExtractor::Extract(*current_packet_, supported_versions_,
                               &validator)) {
-    // TODO(rch): Since there was no CHLO in this packet, buffer it until one
-    // arrives.
-    DLOG(ERROR) << "Dropping undecryptable packet.";
+    DVLOG(1) << "Buffering undecryptable packet.";
+    buffered_packets_.EnqueuePacket(connection_id, *current_packet_,
+                                    current_server_address_,
+                                    current_client_address_);
     return kFateDrop;
   }
 
   if (!validator.can_accept()) {
     // This CHLO is prohibited by policy.
     StatelessConnectionTerminator terminator(connection_id, &framer_, helper(),
                                              time_wait_list_manager_.get());
     terminator.CloseConnection(QUIC_HANDSHAKE_FAILED,
                                validator.error_details());
     OnConnectionClosedStatelessly(QUIC_HANDSHAKE_FAILED);
@@ skipping 38 matching lines @@
   if (disable_quic_pre_30_ != FLAGS_quic_disable_pre_30) {
     DCHECK_EQ(supported_versions_.capacity(),
               allowed_supported_versions_.capacity());
     disable_quic_pre_30_ = FLAGS_quic_disable_pre_30;
     supported_versions_ = FilterSupportedVersions(allowed_supported_versions_);
   }
   return supported_versions_;
 }
 
 }  // namespace net