@fails-components/webtransport 0.0.1-rc.2 → 0.0.1

package/third_party/quiche/quiche/quic/core/quic_stream_test.cc

@@ -480,9 +480,13 @@ TEST_P(QuicStreamTest, WriteOrBufferDataReachStreamLimit) {
       .WillOnce(Invoke(session_.get(), &MockQuicSession::ConsumeData));
   stream_->WriteOrBufferData(data, false, nullptr);
   EXPECT_TRUE(session_->HasUnackedStreamData());
-  EXPECT_CALL(*connection_, CloseConnection(QUIC_STREAM_LENGTH_OVERFLOW, _, _));
-  EXPECT_QUIC_BUG(stream_->WriteOrBufferData("a", false, nullptr),
-                  "Write too many data via stream");
+  EXPECT_QUIC_BUG(
+      {
+        EXPECT_CALL(*connection_,
+                    CloseConnection(QUIC_STREAM_LENGTH_OVERFLOW, _, _));
+        stream_->WriteOrBufferData("a", false, nullptr);
+      },
+      "Write too many data via stream");
 }
 
 TEST_P(QuicStreamTest, ConnectionCloseAfterStreamClose) {
@@ -789,11 +793,14 @@ TEST_P(QuicStreamTest, OnStreamFrameUpperLimit) {
 
 TEST_P(QuicStreamTest, StreamTooLong) {
   Initialize();
-  EXPECT_CALL(*connection_, CloseConnection(QUIC_STREAM_LENGTH_OVERFLOW, _, _))
-      .Times(1);
   QuicStreamFrame stream_frame(stream_->id(), false, kMaxStreamLength, ".");
   EXPECT_QUIC_PEER_BUG(
-      stream_->OnStreamFrame(stream_frame),
+      {
+        EXPECT_CALL(*connection_,
+                    CloseConnection(QUIC_STREAM_LENGTH_OVERFLOW, _, _))
+            .Times(1);
+        stream_->OnStreamFrame(stream_frame);
+      },
       absl::StrCat("Receive stream frame on stream ", stream_->id(),
                    " reaches max stream length"));
 }
@@ -1237,9 +1244,13 @@ TEST_P(QuicStreamTest, WritevDataReachStreamLimit) {
   quiche::QuicheMemSliceStorage storage2(
       &iov2, 1,
       session_->connection()->helper()->GetStreamSendBufferAllocator(), 1024);
-  EXPECT_CALL(*connection_, CloseConnection(QUIC_STREAM_LENGTH_OVERFLOW, _, _));
-  EXPECT_QUIC_BUG(stream_->WriteMemSlices(storage2.ToSpan(), false),
-                  "Write too many data via stream");
+  EXPECT_QUIC_BUG(
+      {
+        EXPECT_CALL(*connection_,
+                    CloseConnection(QUIC_STREAM_LENGTH_OVERFLOW, _, _));
+        stream_->WriteMemSlices(storage2.ToSpan(), false);
+      },
+      "Write too many data via stream");
 }
 
 TEST_P(QuicStreamTest, WriteMemSlices) {
@@ -1328,9 +1339,13 @@ TEST_P(QuicStreamTest, WriteMemSlicesReachStreamLimit) {
   EXPECT_EQ(5u, consumed.bytes_consumed);
 
   quiche::QuicheMemSlice slice2 = MemSliceFromString("6");
-  EXPECT_CALL(*connection_, CloseConnection(QUIC_STREAM_LENGTH_OVERFLOW, _, _));
-  EXPECT_QUIC_BUG(stream_->WriteMemSlice(std::move(slice2), false),
-                  "Write too many data via stream");
+  EXPECT_QUIC_BUG(
+      {
+        EXPECT_CALL(*connection_,
+                    CloseConnection(QUIC_STREAM_LENGTH_OVERFLOW, _, _));
+        stream_->WriteMemSlice(std::move(slice2), false);
+      },
+      "Write too many data via stream");
 }
 
 TEST_P(QuicStreamTest, StreamDataGetAckedMultipleTimes) {

package/third_party/quiche/quiche/quic/core/quic_types.cc

@@ -215,7 +215,6 @@ std::string TransmissionTypeToString(TransmissionType transmission_type) {
     RETURN_STRING_LITERAL(ALL_ZERO_RTT_RETRANSMISSION);
     RETURN_STRING_LITERAL(LOSS_RETRANSMISSION);
     RETURN_STRING_LITERAL(PTO_RETRANSMISSION);
-    RETURN_STRING_LITERAL(PROBING_RETRANSMISSION);
     RETURN_STRING_LITERAL(PATH_RETRANSMISSION);
     RETURN_STRING_LITERAL(ALL_INITIAL_RETRANSMISSION);
     default:

package/third_party/quiche/quiche/quic/core/quic_types.h

@@ -181,7 +181,6 @@ enum TransmissionType : int8_t {
                                 // key.
   LOSS_RETRANSMISSION,          // Retransmits due to loss detection.
   PTO_RETRANSMISSION,           // Retransmission due to probe timeout.
-  PROBING_RETRANSMISSION,       // Retransmission in order to probe bandwidth.
   PATH_RETRANSMISSION,          // Retransmission proactively due to underlying
                                 // network change.
   ALL_INITIAL_RETRANSMISSION,   // Retransmit all packets encrypted with INITIAL
@@ -545,8 +544,6 @@ enum SentPacketState : uint8_t {
   LOST,
   // This packet has been retransmitted when PTO fires.
   PTO_RETRANSMITTED,
-  // This packet has been retransmitted for probing purpose.
-  PROBE_RETRANSMITTED,
   // This packet is sent on a different path or is a PING only packet.
   // Do not update RTT stats and congestion control if the packet is the
   // largest_acked of an incoming ACK.

package/third_party/quiche/quiche/quic/core/quic_utils.cc

@@ -171,7 +171,6 @@ const char* QuicUtils::SentPacketStateToString(SentPacketState state) {
     RETURN_STRING_LITERAL(HANDSHAKE_RETRANSMITTED);
     RETURN_STRING_LITERAL(LOST);
     RETURN_STRING_LITERAL(PTO_RETRANSMITTED);
-    RETURN_STRING_LITERAL(PROBE_RETRANSMITTED);
     RETURN_STRING_LITERAL(NOT_CONTRIBUTING_RTT);
   }
   return "INVALID_SENT_PACKET_STATE";
@@ -289,8 +288,6 @@ SentPacketState QuicUtils::RetransmissionTypeToPacketState(
       return LOST;
     case PTO_RETRANSMISSION:
       return PTO_RETRANSMITTED;
-    case PROBING_RETRANSMISSION:
-      return PROBE_RETRANSMITTED;
     case PATH_RETRANSMISSION:
       return NOT_CONTRIBUTING_RTT;
     case ALL_INITIAL_RETRANSMISSION:

package/third_party/quiche/quiche/quic/core/quic_utils_test.cc

@@ -131,8 +131,6 @@ TEST_F(QuicUtilsTest, RetransmissionTypeToPacketState) {
       EXPECT_EQ(UNACKABLE, state);
     } else if (i == PTO_RETRANSMISSION) {
       EXPECT_EQ(PTO_RETRANSMITTED, state);
-    } else if (i == PROBING_RETRANSMISSION) {
-      EXPECT_EQ(PROBE_RETRANSMITTED, state);
     } else if (i == PATH_RETRANSMISSION) {
       EXPECT_EQ(NOT_CONTRIBUTING_RTT, state);
     } else if (i == ALL_INITIAL_RETRANSMISSION) {

package/third_party/quiche/quiche/quic/core/tls_client_handshaker_test.cc

@@ -577,18 +577,22 @@ TEST_P(TlsClientHandshakerTest, ClientSendsNoSNI) {
 
 TEST_P(TlsClientHandshakerTest, ClientSendingTooManyALPNs) {
   std::string long_alpn(250, 'A');
-  EXPECT_CALL(*session_, GetAlpnsToOffer())
-      .WillOnce(testing::Return(std::vector<std::string>({
-          long_alpn + "1",
-          long_alpn + "2",
-          long_alpn + "3",
-          long_alpn + "4",
-          long_alpn + "5",
-          long_alpn + "6",
-          long_alpn + "7",
-          long_alpn + "8",
-      })));
-  EXPECT_QUIC_BUG(stream()->CryptoConnect(), "Failed to set ALPN");
+  EXPECT_QUIC_BUG(
+      {
+        EXPECT_CALL(*session_, GetAlpnsToOffer())
+            .WillOnce(testing::Return(std::vector<std::string>({
+                long_alpn + "1",
+                long_alpn + "2",
+                long_alpn + "3",
+                long_alpn + "4",
+                long_alpn + "5",
+                long_alpn + "6",
+                long_alpn + "7",
+                long_alpn + "8",
+            })));
+        stream()->CryptoConnect();
+      },
+      "Failed to set ALPN");
 }
 
 TEST_P(TlsClientHandshakerTest, ServerRequiresCustomALPN) {

package/third_party/quiche/quiche/quic/core/tls_handshaker.cc

@@ -85,7 +85,7 @@ bool TlsHandshaker::ProcessInput(absl::string_view input,
 }
 
 void TlsHandshaker::AdvanceHandshake() {
-  if (is_connection_closed_) {
+  if (is_connection_closed()) {
     return;
   }
   if (GetHandshakeState() >= HANDSHAKE_COMPLETE) {
@@ -101,6 +101,13 @@ void TlsHandshaker::AdvanceHandshake() {
   QUIC_VLOG(1) << ENDPOINT << "Continuing handshake";
   int rv = SSL_do_handshake(ssl());
 
+  if (GetQuicReloadableFlag(quic_tls_handshaker_check_connection_closed) &&
+      is_connection_closed()) {
+    QUIC_RELOADABLE_FLAG_COUNT_N(quic_tls_handshaker_check_connection_closed, 1,
+                                 2);
+    return;
+  }
+
   // If SSL_do_handshake return success(1) and we are in early data, it is
   // possible that we have provided ServerHello to BoringSSL but it hasn't been
   // processed. Retry SSL_do_handshake once will advance the handshake more in
@@ -109,6 +116,14 @@ void TlsHandshaker::AdvanceHandshake() {
   if (rv == 1 && SSL_in_early_data(ssl())) {
     OnEnterEarlyData();
     rv = SSL_do_handshake(ssl());
+
+    if (GetQuicReloadableFlag(quic_tls_handshaker_check_connection_closed) &&
+        is_connection_closed()) {
+      QUIC_RELOADABLE_FLAG_COUNT_N(quic_tls_handshaker_check_connection_closed,
+                                   2, 2);
+      return;
+    }
+
     QUIC_VLOG(1) << ENDPOINT
                  << "SSL_do_handshake returned when entering early data. After "
                  << "retry, rv=" << rv
@@ -120,7 +135,7 @@ void TlsHandshaker::AdvanceHandshake() {
     //   SSL_in_early_data should be false.
     //
     // In either case, it should not both return 1 and stay in early data.
-    if (rv == 1 && SSL_in_early_data(ssl()) && !is_connection_closed_) {
+    if (rv == 1 && SSL_in_early_data(ssl()) && !is_connection_closed()) {
       QUIC_BUG(quic_handshaker_stay_in_early_data)
           << "The original and the retry of SSL_do_handshake both returned "
              "success and in early data";
@@ -139,7 +154,7 @@ void TlsHandshaker::AdvanceHandshake() {
     return;
   }
   if (ShouldCloseConnectionOnUnexpectedError(ssl_error) &&
-      !is_connection_closed_) {
+      !is_connection_closed()) {
     QUIC_VLOG(1) << "SSL_do_handshake failed; SSL_get_error returns "
                  << ssl_error;
     ERR_print_errors_fp(stderr);

package/third_party/quiche/quiche/quic/qbone/platform/internet_checksum.cc

@@ -4,15 +4,20 @@
 
 #include "quiche/quic/qbone/platform/internet_checksum.h"
 
+#include <stdint.h>
+#include <string.h>
+
 namespace quic {
 
 void InternetChecksum::Update(const char* data, size_t size) {
   const char* current;
   for (current = data; current + 1 < data + size; current += 2) {
-    accumulator_ += *reinterpret_cast<const uint16_t*>(current);
+    uint16_t v;
+    memcpy(&v, current, sizeof(v));
+    accumulator_ += v;
   }
   if (current < data + size) {
-    accumulator_ += *reinterpret_cast<const uint8_t*>(current);
+    accumulator_ += *reinterpret_cast<const unsigned char*>(current);
   }
 }
 

package/third_party/quiche/quiche/quic/test_tools/crypto_test_utils.cc

@@ -384,7 +384,7 @@ void CommunicateHandshakeMessages(PacketSavingConnection* client_conn,
                    << client_conn->encrypted_packets_.size() - client_i
                    << " packets client->server";
     MovePackets(client_conn, &client_i, server, server_conn,
-                Perspective::IS_SERVER);
+                Perspective::IS_SERVER, /*process_stream_data=*/false);
 
     if (client->one_rtt_keys_available() && server->one_rtt_keys_available() &&
         server_conn->encrypted_packets_.size() == server_i) {
@@ -395,7 +395,7 @@ void CommunicateHandshakeMessages(PacketSavingConnection* client_conn,
                    << server_conn->encrypted_packets_.size() - server_i
                    << " packets server->client";
     MovePackets(server_conn, &server_i, client, client_conn,
-                Perspective::IS_CLIENT);
+                Perspective::IS_CLIENT, /*process_stream_data=*/false);
   }
 }
 
@@ -404,7 +404,8 @@ bool CommunicateHandshakeMessagesUntil(PacketSavingConnection* client_conn,
                                        std::function<bool()> client_condition,
                                        PacketSavingConnection* server_conn,
                                        QuicCryptoStream* server,
-                                       std::function<bool()> server_condition) {
+                                       std::function<bool()> server_condition,
+                                       bool process_stream_data) {
   size_t client_next_packet_to_deliver =
       client_conn->number_of_packets_delivered_;
   size_t server_next_packet_to_deliver =
@@ -421,7 +422,7 @@ bool CommunicateHandshakeMessagesUntil(PacketSavingConnection* client_conn,
                             client_next_packet_to_deliver
                      << " packets client->server";
       MovePackets(client_conn, &client_next_packet_to_deliver, server,
-                  server_conn, Perspective::IS_SERVER);
+                  server_conn, Perspective::IS_SERVER, process_stream_data);
     }
     if (!client_condition()) {
       QUIC_LOG(INFO) << "Processing "
@@ -429,7 +430,7 @@ bool CommunicateHandshakeMessagesUntil(PacketSavingConnection* client_conn,
                             server_next_packet_to_deliver
                      << " packets server->client";
       MovePackets(server_conn, &server_next_packet_to_deliver, client,
-                  client_conn, Perspective::IS_CLIENT);
+                  client_conn, Perspective::IS_CLIENT, process_stream_data);
     }
   }
   client_conn->number_of_packets_delivered_ = client_next_packet_to_deliver;
@@ -457,7 +458,7 @@ std::pair<size_t, size_t> AdvanceHandshake(PacketSavingConnection* client_conn,
                    << client_conn->encrypted_packets_.size() - client_i
                    << " packets client->server";
     MovePackets(client_conn, &client_i, server, server_conn,
-                Perspective::IS_SERVER);
+                Perspective::IS_SERVER, /*process_stream_data=*/false);
   }
 
   if (server_conn->encrypted_packets_.size() != server_i) {
@@ -465,7 +466,7 @@ std::pair<size_t, size_t> AdvanceHandshake(PacketSavingConnection* client_conn,
                    << server_conn->encrypted_packets_.size() - server_i
                    << " packets server->client";
     MovePackets(server_conn, &server_i, client, client_conn,
-                Perspective::IS_CLIENT);
+                Perspective::IS_CLIENT, /*process_stream_data=*/false);
   }
 
   return std::make_pair(client_i, server_i);
@@ -709,7 +710,7 @@ CryptoHandshakeMessage CreateCHLO(
 void MovePackets(PacketSavingConnection* source_conn,
                  size_t* inout_packet_index, QuicCryptoStream* dest_stream,
                  PacketSavingConnection* dest_conn,
-                 Perspective dest_perspective) {
+                 Perspective dest_perspective, bool process_stream_data) {
   SimpleQuicFramer framer(source_conn->supported_versions(), dest_perspective);
   QuicFramerPeer::SetLastSerializedServerConnectionId(framer.framer(),
                                                       TestConnectionId());
@@ -779,10 +780,17 @@ void MovePackets(PacketSavingConnection* source_conn,
     QuicConnectionPeer::SetCurrentPacket(
         dest_conn, source_conn->encrypted_packets_[index]->AsStringPiece());
     for (const auto& stream_frame : framer.stream_frames()) {
-      // Ignore stream frames that are sent on other streams in the crypto
-      // event.
-      if (stream_frame->stream_id == dest_stream->id()) {
-        dest_stream->OnStreamFrame(*stream_frame);
+      if (process_stream_data &&
+          dest_stream->handshake_protocol() == PROTOCOL_TLS1_3) {
+        // Deliver STREAM_FRAME such that application state is available and can
+        // be stored along with resumption ticket in session cache,
+        dest_conn->OnStreamFrame(*stream_frame);
+      } else {
+        // Ignore stream frames that are sent on other streams in the crypto
+        // event.
+        if (stream_frame->stream_id == dest_stream->id()) {
+          dest_stream->OnStreamFrame(*stream_frame);
+        }
       }
     }
     for (const auto& crypto_frame : framer.crypto_frames()) {

package/third_party/quiche/quiche/quic/test_tools/crypto_test_utils.h

@@ -109,15 +109,18 @@ void CommunicateHandshakeMessages(PacketSavingConnection* client_conn,
 // CommunicateHandshakeMessagesUntil:
 // 1) Moves messages from |client| to |server| until |server_condition| is met.
 // 2) Moves messages from |server| to |client| until |client_condition| is met.
-// 3) Returns true if both conditions are met.
-// 4) Returns false if either connection is closed or there is no more packet to
+// 3)  For IETF QUIC, if `process_stream_data` is true, STREAM_FRAME within the
+// packet containing crypto messages is also processed.
+// 4) Returns true if both conditions are met.
+// 5) Returns false if either connection is closed or there is no more packet to
 // deliver before both conditions are met.
 bool CommunicateHandshakeMessagesUntil(PacketSavingConnection* client_conn,
                                        QuicCryptoStream* client,
                                        std::function<bool()> client_condition,
                                        PacketSavingConnection* server_conn,
                                        QuicCryptoStream* server,
-                                       std::function<bool()> server_condition);
+                                       std::function<bool()> server_condition,
+                                       bool process_stream_data);
 
 // AdvanceHandshake attempts to moves messages from |client| to |server| and
 // |server| to |client|. Returns the number of messages moved.
@@ -176,11 +179,13 @@ CryptoHandshakeMessage CreateCHLO(
 // MovePackets parses crypto handshake messages from packet number
 // |*inout_packet_index| through to the last packet (or until a packet fails
 // to decrypt) and has |dest_stream| process them. |*inout_packet_index| is
-// updated with an index one greater than the last packet processed.
+// updated with an index one greater than the last packet processed. For IETF
+// QUIC, if `process_stream_data` is true, STREAM_FRAME within the packet
+// containing crypto messages is also processed.
 void MovePackets(PacketSavingConnection* source_conn,
                  size_t* inout_packet_index, QuicCryptoStream* dest_stream,
                  PacketSavingConnection* dest_conn,
-                 Perspective dest_perspective);
+                 Perspective dest_perspective, bool process_stream_data);
 
 // Return an inchoate CHLO with some basic tag value pairs.
 CryptoHandshakeMessage GenerateDefaultInchoateCHLO(

package/third_party/quiche/quiche/quic/test_tools/quic_test_utils.h

@@ -453,7 +453,6 @@ class MockQuicConnectionVisitor : public QuicConnectionVisitorInterface {
               (override));
   MOCK_METHOD(void, OnWriteBlocked, (), (override));
   MOCK_METHOD(void, OnCanWrite, (), (override));
-  MOCK_METHOD(bool, SendProbingData, (), (override));
   MOCK_METHOD(void, OnCongestionWindowChange, (QuicTime now), (override));
   MOCK_METHOD(void, OnConnectionMigration, (AddressChangeType type),
               (override));
@@ -1209,7 +1208,6 @@ class MockSendAlgorithm : public SendAlgorithmInterface {
   MOCK_METHOD(std::string, GetDebugState, (), (const, override));
   MOCK_METHOD(bool, InSlowStart, (), (const, override));
   MOCK_METHOD(bool, InRecovery, (), (const, override));
-  MOCK_METHOD(bool, ShouldSendProbingPacket, (), (const, override));
   MOCK_METHOD(QuicByteCount, GetSlowStartThreshold, (), (const, override));
   MOCK_METHOD(CongestionControlType, GetCongestionControlType, (),
               (const, override));

package/third_party/quiche/quiche/quic/test_tools/simulator/quic_endpoint.cc

@@ -151,14 +151,6 @@ void QuicEndpoint::OnCanWrite() {
   WriteStreamData();
 }
 
-bool QuicEndpoint::SendProbingData() {
-  if (connection()->sent_packet_manager().MaybeRetransmitOldestPacket(
-          PROBING_RETRANSMISSION)) {
-    return true;
-  }
-  return false;
-}
-
 bool QuicEndpoint::WillingAndAbleToWrite() const {
   if (notifier_ != nullptr) {
     return notifier_->WillingToWrite();

package/third_party/quiche/quiche/quic/test_tools/simulator/quic_endpoint.h

@@ -46,7 +46,6 @@ class QuicEndpoint : public QuicEndpointBase,
   void OnStreamFrame(const QuicStreamFrame& frame) override;
   void OnCryptoFrame(const QuicCryptoFrame& frame) override;
   void OnCanWrite() override;
-  bool SendProbingData() override;
   bool WillingAndAbleToWrite() const override;
   bool ShouldKeepConnectionAlive() const override;
 

package/third_party/quiche/quiche/quic/tools/quic_simple_server_stream_test.cc

@@ -65,7 +65,8 @@ class TestStream : public QuicSimpleServerStream {
 
   MOCK_METHOD(void, WriteHeadersMock, (bool fin), ());
   MOCK_METHOD(void, WriteEarlyHintsHeadersMock, (bool fin), ());
-  MOCK_METHOD(void, WriteOrBufferBody, (absl::string_view data, bool fin), ());
+  MOCK_METHOD(void, WriteOrBufferBody, (absl::string_view data, bool fin),
+              (override));
 
   size_t WriteHeaders(
       spdy::Http2HeaderBlock header_block, bool fin,