Limits only 16 new QUIC connections can be opened per epoll event.

net/quic/core/quic_buffered_packet_store.cc

 // Copyright (c) 2016 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/core/quic_buffered_packet_store.h"
 
 #include <list>
 
 #include "base/stl_util.h"
+#include "net/quic/core/quic_bug_tracker.h"
 
 using std::list;
 
 namespace net {
 
 typedef QuicBufferedPacketStore::BufferedPacket BufferedPacket;
 typedef QuicBufferedPacketStore::EnqueuePacketResult EnqueuePacketResult;
 typedef QuicBufferedPacketStore::BufferedPacketList BufferedPacketList;
 
 // Max number of connections this store can keep track.
 static const size_t kDefaultMaxConnectionsInStore = 100;
+// Up to half of the capacity can be used for storing non-CHLO packets.
+static const size_t kMaxConnectionsWithoutCHLO =
+    kDefaultMaxConnectionsInStore / 2;
 
 namespace {
 
 // This alarm removes expired entries in map each time this alarm fires.
 class ConnectionExpireAlarm : public QuicAlarm::Delegate {
  public:
   explicit ConnectionExpireAlarm(QuicBufferedPacketStore* store)
       : connection_store_(store) {}
 
   void OnAlarm() override { connection_store_->OnExpirationTimeout(); }
@@ skipping 40 matching lines @@
       clock_(clock),
       expiration_alarm_(
           alarm_factory->CreateAlarm(new ConnectionExpireAlarm(this))) {}
 
 QuicBufferedPacketStore::~QuicBufferedPacketStore() {}
 
 EnqueuePacketResult QuicBufferedPacketStore::EnqueuePacket(
     QuicConnectionId connection_id,
     const QuicReceivedPacket& packet,
     IPEndPoint server_address,
-    IPEndPoint client_address) {
-  if (!base::ContainsKey(undecryptable_packets_, connection_id) && IsFull()) {
-    // Drop the packet if store can't keep track of more connections.
+    IPEndPoint client_address,
+    bool is_chlo) {
+  QUIC_BUG_IF(is_chlo &&
+              base::ContainsKey(connections_with_chlo_, connection_id))
+      << "Shouldn't buffer duplicated CHLO on connection " << connection_id;
+
+  if (!base::ContainsKey(undecryptable_packets_, connection_id) &&
+      ShouldBufferPacket(is_chlo)) {
+    // Drop the packet if the upper limit of undecryptable packets has been
+    // reached or the whole capacity of the store has been reached.
     return TOO_MANY_CONNECTIONS;
   } else if (!base::ContainsKey(undecryptable_packets_, connection_id)) {
     undecryptable_packets_.emplace(
         std::make_pair(connection_id, BufferedPacketList()));
   }
   CHECK(base::ContainsKey(undecryptable_packets_, connection_id));
   BufferedPacketList& queue =
       undecryptable_packets_.find(connection_id)->second;
 
-  if (queue.buffered_packets.size() >= kDefaultMaxUndecryptablePackets) {
-    // If there are kMaxBufferedPacketsPerConnection packets buffered up for
-    // this connection, drop the current packet.
-    return TOO_MANY_PACKETS;
+  if (!is_chlo) {
+    // If current packet is not CHLO, it might not be buffered because store
+    // only buffers certain number of undecryptable packets per connection.
+    size_t num_non_chlo_packets =
+        base::ContainsKey(connections_with_chlo_, connection_id)
+            ? (queue.buffered_packets.size() - 1)
+            : queue.buffered_packets.size();
+    if (num_non_chlo_packets >= kDefaultMaxUndecryptablePackets) {
+      // If there are kMaxBufferedPacketsPerConnection packets buffered up for
+      // this connection, drop the current packet.
+      return TOO_MANY_PACKETS;
+    }
   }
 
   if (queue.buffered_packets.empty()) {
     // If this is the first packet arrived on a new connection, initialize the
     // creation time.
     queue.creation_time = clock_->ApproximateNow();
   }
 
   BufferedPacket new_entry(std::unique_ptr<QuicReceivedPacket>(packet.Clone()),
                            server_address, client_address);
-
-  queue.buffered_packets.push_back(std::move(new_entry));
-
+  if (is_chlo) {
+    // Add CHLO to the beginning of buffered packets so that it can be delivered
+    // first later.
+    queue.buffered_packets.push_front(std::move(new_entry));
+    connections_with_chlo_[connection_id] = false;  // Dummy value.
+  } else {
+    // Buffer non-CHLO packets in arrival order.
+    queue.buffered_packets.push_back(std::move(new_entry));
+  }
   MaybeSetExpirationAlarm();
   return SUCCESS;
 }
 
 bool QuicBufferedPacketStore::HasBufferedPackets(
     QuicConnectionId connection_id) const {
   return base::ContainsKey(undecryptable_packets_, connection_id);
 }
 
+bool QuicBufferedPacketStore::HasChlosBuffered() const {
+  return !connections_with_chlo_.empty();
+}
+
 list<BufferedPacket> QuicBufferedPacketStore::DeliverPackets(
     QuicConnectionId connection_id) {
   list<BufferedPacket> packets_to_deliver;
   auto it = undecryptable_packets_.find(connection_id);
   if (it != undecryptable_packets_.end()) {
     packets_to_deliver = std::move(it->second.buffered_packets);
     undecryptable_packets_.erase(connection_id);
   }
   return packets_to_deliver;
 }
 
 void QuicBufferedPacketStore::OnExpirationTimeout() {
   QuicTime expiration_time = clock_->ApproximateNow() - connection_life_span_;
   while (!undecryptable_packets_.empty()) {
     auto& entry = undecryptable_packets_.front();
     if (entry.second.creation_time > expiration_time) {
       break;
     }
-    visitor_->OnExpiredPackets(entry.first, std::move(entry.second));
+    QuicConnectionId connection_id = entry.first;
+    visitor_->OnExpiredPackets(connection_id, std::move(entry.second));
     undecryptable_packets_.erase(undecryptable_packets_.begin());
+    connections_with_chlo_.erase(connection_id);
   }
   if (!undecryptable_packets_.empty()) {
     expiration_alarm_->Set(clock_->ApproximateNow() + connection_life_span_);
   }
 }
 
 void QuicBufferedPacketStore::MaybeSetExpirationAlarm() {
   if (!expiration_alarm_->IsSet()) {
     expiration_alarm_->Set(clock_->ApproximateNow() + connection_life_span_);
   }
 }
 
-bool QuicBufferedPacketStore::IsFull() {
-  return undecryptable_packets_.size() >= kDefaultMaxConnectionsInStore;
+bool QuicBufferedPacketStore::ShouldBufferPacket(bool is_chlo) {
+  bool is_store_full =
+      undecryptable_packets_.size() >= kDefaultMaxConnectionsInStore;
+
+  if (is_chlo) {
+    return is_store_full;
+  }
+
+  size_t num_connections_without_chlo =
+      undecryptable_packets_.size() - connections_with_chlo_.size();
+  bool reach_non_chlo_limit =
+      FLAGS_quic_limit_num_new_sessions_per_epoll_loop &&
+      num_connections_without_chlo >= kMaxConnectionsWithoutCHLO;
+
+  return is_store_full || reach_non_chlo_limit;
+}
+
+list<BufferedPacket> QuicBufferedPacketStore::DeliverPacketsForNextConnection(
+    QuicConnectionId* connection_id) {
+  if (connections_with_chlo_.empty()) {
+    // Returns empty list if no CHLO has been buffered.
+    return list<BufferedPacket>();
+  }
+  *connection_id = connections_with_chlo_.front().first;
+  connections_with_chlo_.erase(connections_with_chlo_.begin());
+
+  list<BufferedPacket> packets = DeliverPackets(*connection_id);
+  DCHECK(!packets.empty()) << "Try to deliver connectons without CHLO";
+  return packets;
+}
+
+bool QuicBufferedPacketStore::HasChloForConnection(
+    QuicConnectionId connection_id) {
+  return base::ContainsKey(connections_with_chlo_, connection_id);
 }
 
 }  // namespace net