Landing Recent QUIC Changes.

Making the (deprecation-in-progress) congestion field write only.

This is a bit of a hack because technically it's "required" for
QUIC_VERSION_23 but as all the internal servers and all of chrome builds
picking up this change consider the field optional despite the version,
it should just Work (TM).

I was hoping to stop sending the congestion fields for v24 clients but
that is not safe until the internal server fleet doesn't consider it a
required field for negotiated()=true.  Bah.

No longer reading the (deprecated) congestion fields for QUIC.

Merge internal change: 85158634
https://codereview.chromium.org/898233003/

Improving junk packet handling for QUIC by ignoring packets with client
port 0.

Merge internal change: 85067984
https://codereview.chromium.org/885713009/

Removing deprecated flag FLAGS_quic_use_initial_rtt_for_stats.

Merge internal change: 84999682
https://codereview.chromium.org/883393008/

Adding more error logging for failed QUIC writes.

Merge internal change: 84989992
https://codereview.chromium.org/898243002/

Further cleanup to QuicAckNotifier and QuicAckNotifierManager.
No functional change.

Merge internal change: 84784925
https://codereview.chromium.org/880403006/

Remove an unneeded hash_set from QuicAckNotifierManager.
No change in behavior.

Merge internal change: 84637544
https://codereview.chromium.org/872403007/

Minor cleanup and optimization of QuicConnection::IsConnectionClose.

Merge internal change: 84624803
https://codereview.chromium.org/903973002/

Rename QuicAckNotifier's AddSequenceNumber to OnSerializedPacket.
No functional change.

Merge internal change: 84624660
https://codereview.chromium.org/867293004/

R=rch@chromium.org

Committed: https://crrev.com/ff331b65e0aef293ed6f1d0954b83ae17cc66d28
Cr-Commit-Position: refs/heads/master@{#315086}

Review URL: https://codereview.chromium.org/903013002

Cr-Commit-Position: refs/heads/master@{#315115}

2 files changed, 54 insertions, 30 deletions

diff --git a/net/tools/quic/quic_dispatcher.cc b/net/tools/quic/quic_dispatcher.cc
index 1771026..46f672ea 100644
--- a/net/tools/quic/quic_dispatcher.cc
+++ b/net/tools/quic/quic_dispatcher.cc
@@ -209,6 +209,13 @@ bool QuicDispatcher::OnUnauthenticatedPublicHeader(
     const QuicPacketPublicHeader& header) {
   QuicSession* session = nullptr;
 
+  // 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 black hole
+  // it.
+  if (current_client_address_.port() == 0) {
+    return false;
+  }
+
   QuicConnectionId connection_id = header.connection_id;
   SessionMap::iterator it = session_map_.find(connection_id);
   if (it == session_map_.end()) {
diff --git a/net/tools/quic/quic_dispatcher_test.cc b/net/tools/quic/quic_dispatcher_test.cc
index fc1e10d..6ef1b16 100644
--- a/net/tools/quic/quic_dispatcher_test.cc
+++ b/net/tools/quic/quic_dispatcher_test.cc
@@ -97,12 +97,29 @@ QuicSession* CreateSession(QuicDispatcher* dispatcher,
   return *session;
 }
 
+class MockTimeWaitListManager : public QuicTimeWaitListManager {
+ public:
+  MockTimeWaitListManager(QuicPacketWriter* writer,
+                          QuicServerSessionVisitor* visitor,
+                          EpollServer* eps)
+      : QuicTimeWaitListManager(writer, visitor, eps, QuicSupportedVersions()) {
+  }
+
+  MOCK_METHOD5(ProcessPacket,
+               void(const IPEndPoint& server_address,
+                    const IPEndPoint& client_address,
+                    QuicConnectionId connection_id,
+                    QuicPacketSequenceNumber sequence_number,
+                    const QuicEncryptedPacket& packet));
+};
+
 class QuicDispatcherTest : public ::testing::Test {
  public:
   QuicDispatcherTest()
       : crypto_config_(QuicCryptoServerConfig::TESTING,
                        QuicRandom::GetInstance()),
         dispatcher_(config_, crypto_config_, &eps_),
+        time_wait_list_manager_(nullptr),
         session1_(nullptr),
         session2_(nullptr) {
     dispatcher_.Initialize(1);
@@ -133,11 +150,20 @@ class QuicDispatcherTest : public ::testing::Test {
     EXPECT_EQ(data_, packet.AsStringPiece());
   }
 
+  void CreateTimeWaitListManager() {
+    time_wait_list_manager_ = new MockTimeWaitListManager(
+        QuicDispatcherPeer::GetWriter(&dispatcher_), &dispatcher_, &eps_);
+    // dispatcher takes the ownership of time_wait_list_manager.
+    QuicDispatcherPeer::SetTimeWaitListManager(&dispatcher_,
+                                               time_wait_list_manager_);
+  }
+
   EpollServer eps_;
   QuicConfig config_;
   QuicCryptoServerConfig crypto_config_;
   IPEndPoint server_address_;
   TestDispatcher dispatcher_;
+  MockTimeWaitListManager* time_wait_list_manager_;
   MockSession* session1_;
   MockSession* session2_;
   string data_;
@@ -184,28 +210,9 @@ TEST_F(QuicDispatcherTest, Shutdown) {
   dispatcher_.Shutdown();
 }
 
-class MockTimeWaitListManager : public QuicTimeWaitListManager {
- public:
-  MockTimeWaitListManager(QuicPacketWriter* writer,
-                          QuicServerSessionVisitor* visitor,
-                          EpollServer* eps)
-      : QuicTimeWaitListManager(writer, visitor, eps, QuicSupportedVersions()) {
-  }
-
-  MOCK_METHOD5(ProcessPacket, void(const IPEndPoint& server_address,
-                                   const IPEndPoint& client_address,
-                                   QuicConnectionId connection_id,
-                                   QuicPacketSequenceNumber sequence_number,
-                                   const QuicEncryptedPacket& packet));
-};
-
 TEST_F(QuicDispatcherTest, TimeWaitListManager) {
-  MockTimeWaitListManager* time_wait_list_manager =
-      new MockTimeWaitListManager(
-          QuicDispatcherPeer::GetWriter(&dispatcher_), &dispatcher_, &eps_);
-  // dispatcher takes the ownership of time_wait_list_manager.
-  QuicDispatcherPeer::SetTimeWaitListManager(&dispatcher_,
-                                             time_wait_list_manager);
+  CreateTimeWaitListManager();
+
   // Create a new session.
   IPEndPoint client_address(net::test::Loopback4(), 1);
   QuicConnectionId connection_id = 1;
@@ -233,34 +240,44 @@ TEST_F(QuicDispatcherTest, TimeWaitListManager) {
           reinterpret_cast<MockConnection*>(session1_->connection()),
           &MockConnection::ReallyProcessUdpPacket));
   dispatcher_.ProcessPacket(IPEndPoint(), client_address, *encrypted);
-  EXPECT_TRUE(time_wait_list_manager->IsConnectionIdInTimeWait(connection_id));
+  EXPECT_TRUE(time_wait_list_manager_->IsConnectionIdInTimeWait(connection_id));
 
   // Dispatcher forwards subsequent packets for this connection_id to the time
   // wait list manager.
-  EXPECT_CALL(*time_wait_list_manager,
+  EXPECT_CALL(*time_wait_list_manager_,
               ProcessPacket(_, _, connection_id, _, _)).Times(1);
   ProcessPacket(client_address, connection_id, true, "foo");
 }
 
 TEST_F(QuicDispatcherTest, StrayPacketToTimeWaitListManager) {
-  MockTimeWaitListManager* time_wait_list_manager =
-      new MockTimeWaitListManager(
-          QuicDispatcherPeer::GetWriter(&dispatcher_), &dispatcher_, &eps_);
-  // dispatcher takes the ownership of time_wait_list_manager.
-  QuicDispatcherPeer::SetTimeWaitListManager(&dispatcher_,
-                                             time_wait_list_manager);
+  CreateTimeWaitListManager();
 
   IPEndPoint client_address(net::test::Loopback4(), 1);
   QuicConnectionId connection_id = 1;
   // Dispatcher forwards all packets for this connection_id to the time wait
   // list manager.
   EXPECT_CALL(dispatcher_, CreateQuicSession(_, _, _)).Times(0);
-  EXPECT_CALL(*time_wait_list_manager,
+  EXPECT_CALL(*time_wait_list_manager_,
               ProcessPacket(_, _, connection_id, _, _)).Times(1);
   string data = "foo";
   ProcessPacket(client_address, connection_id, false, "foo");
 }
 
+TEST_F(QuicDispatcherTest, ProcessPacketWithBogusPort) {
+  CreateTimeWaitListManager();
+
+  IPEndPoint client_address(net::test::Loopback4(), 0);
+  IPAddressNumber any4;
+  CHECK(net::ParseIPLiteralToNumber("0.0.0.0", &any4));
+  server_address_ = IPEndPoint(any4, 5);
+
+  EXPECT_CALL(dispatcher_, CreateQuicSession(1, _, client_address)).Times(0);
+  EXPECT_CALL(*time_wait_list_manager_, ProcessPacket(_, _, _, _, _)).Times(0);
+  ProcessPacket(client_address, 1, true, "foo");
+  EXPECT_EQ(client_address, dispatcher_.current_client_address());
+  EXPECT_EQ(server_address_, dispatcher_.current_server_address());
+}
+
 class BlockingWriter : public QuicPacketWriterWrapper {
  public:
   BlockingWriter() : write_blocked_(false) {}