@fails-components/webtransport 0.0.1 → 0.0.2

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

@@ -18,6 +18,7 @@
 #include "quiche/quic/core/crypto/null_encrypter.h"
 #include "quiche/quic/core/crypto/quic_decrypter.h"
 #include "quiche/quic/core/crypto/quic_encrypter.h"
+#include "quiche/quic/core/frames/quic_frame.h"
 #include "quiche/quic/core/frames/quic_stream_frame.h"
 #include "quiche/quic/core/quic_connection_id.h"
 #include "quiche/quic/core/quic_data_writer.h"
@@ -1927,6 +1928,10 @@ TEST_P(QuicPacketCreatorTest, PacketTransmissionType) {
                                          absl::string_view()));
   ASSERT_TRUE(QuicUtils::IsRetransmittableFrame(stream_frame.type));
 
+  QuicFrame stream_frame_2(QuicStreamFrame(stream_id,
+                                           /*fin=*/false, 1u,
+                                           absl::string_view()));
+
   QuicFrame padding_frame{QuicPaddingFrame()};
   ASSERT_FALSE(QuicUtils::IsRetransmittableFrame(padding_frame.type));
 
@@ -1939,16 +1944,154 @@ TEST_P(QuicPacketCreatorTest, PacketTransmissionType) {
   EXPECT_TRUE(creator_.AddFrame(stream_frame, PTO_RETRANSMISSION));
   ASSERT_EQ(serialized_packet_, nullptr);
 
-  EXPECT_TRUE(creator_.AddFrame(padding_frame, LOSS_RETRANSMISSION));
+  EXPECT_TRUE(creator_.AddFrame(stream_frame_2, PATH_RETRANSMISSION));
+  ASSERT_EQ(serialized_packet_, nullptr);
+
+  EXPECT_TRUE(creator_.AddFrame(padding_frame, PTO_RETRANSMISSION));
   creator_.FlushCurrentPacket();
   ASSERT_TRUE(serialized_packet_->encrypted_buffer);
 
   // The last retransmittable frame on packet is a stream frame, the packet's
   // transmission type should be the same as the stream frame's.
-  EXPECT_EQ(serialized_packet_->transmission_type, PTO_RETRANSMISSION);
+  EXPECT_EQ(serialized_packet_->transmission_type, PATH_RETRANSMISSION);
+  DeleteSerializedPacket();
+}
+
+TEST_P(QuicPacketCreatorTest,
+       PacketBytesRetransmitted_AddFrame_Retransmission) {
+  creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
+
+  QuicAckFrame temp_ack_frame = InitAckFrame(1);
+  QuicFrame ack_frame(&temp_ack_frame);
+  EXPECT_TRUE(creator_.AddFrame(ack_frame, LOSS_RETRANSMISSION));
+
+  QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
+      client_framer_.transport_version(), Perspective::IS_CLIENT);
+
+  QuicFrame stream_frame;
+  const std::string data("data");
+  // ConsumeDataToFillCurrentPacket calls AddFrame
+  ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
+      stream_id, data, 0u, false, false, PTO_RETRANSMISSION, &stream_frame));
+  EXPECT_EQ(4u, stream_frame.stream_frame.data_length);
+
+  EXPECT_CALL(delegate_, OnSerializedPacket(_))
+      .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
+
+  creator_.FlushCurrentPacket();
+  ASSERT_TRUE(serialized_packet_->encrypted_buffer);
+  ASSERT_FALSE(serialized_packet_->bytes_not_retransmitted.has_value());
+
   DeleteSerializedPacket();
 }
 
+TEST_P(QuicPacketCreatorTest,
+       PacketBytesRetransmitted_AddFrame_NotRetransmission) {
+  creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
+
+  QuicAckFrame temp_ack_frame = InitAckFrame(1);
+  QuicFrame ack_frame(&temp_ack_frame);
+  EXPECT_TRUE(creator_.AddFrame(ack_frame, NOT_RETRANSMISSION));
+
+  QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
+      client_framer_.transport_version(), Perspective::IS_CLIENT);
+
+  QuicFrame stream_frame;
+  const std::string data("data");
+  // ConsumeDataToFillCurrentPacket calls AddFrame
+  ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
+      stream_id, data, 0u, false, false, NOT_RETRANSMISSION, &stream_frame));
+  EXPECT_EQ(4u, stream_frame.stream_frame.data_length);
+
+  EXPECT_CALL(delegate_, OnSerializedPacket(_))
+      .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
+
+  creator_.FlushCurrentPacket();
+  ASSERT_TRUE(serialized_packet_->encrypted_buffer);
+  ASSERT_FALSE(serialized_packet_->bytes_not_retransmitted.has_value());
+
+  DeleteSerializedPacket();
+}
+
+TEST_P(QuicPacketCreatorTest, PacketBytesRetransmitted_AddFrame_MixedFrames) {
+  creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
+
+  QuicAckFrame temp_ack_frame = InitAckFrame(1);
+  QuicFrame ack_frame(&temp_ack_frame);
+  EXPECT_TRUE(creator_.AddFrame(ack_frame, NOT_RETRANSMISSION));
+
+  QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
+      client_framer_.transport_version(), Perspective::IS_CLIENT);
+
+  QuicFrame stream_frame;
+  const std::string data("data");
+  // ConsumeDataToFillCurrentPacket calls AddFrame
+  ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
+      stream_id, data, 0u, false, false, NOT_RETRANSMISSION, &stream_frame));
+  EXPECT_EQ(4u, stream_frame.stream_frame.data_length);
+
+  QuicFrame stream_frame2;
+  // ConsumeDataToFillCurrentPacket calls AddFrame
+  ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
+      stream_id, data, 0u, false, false, LOSS_RETRANSMISSION, &stream_frame2));
+  EXPECT_EQ(4u, stream_frame2.stream_frame.data_length);
+
+  EXPECT_CALL(delegate_, OnSerializedPacket(_))
+      .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
+
+  creator_.FlushCurrentPacket();
+  ASSERT_TRUE(serialized_packet_->encrypted_buffer);
+  ASSERT_TRUE(serialized_packet_->bytes_not_retransmitted.has_value());
+  ASSERT_GE(serialized_packet_->bytes_not_retransmitted.value(), 4u);
+
+  DeleteSerializedPacket();
+}
+
+TEST_P(QuicPacketCreatorTest,
+       PacketBytesRetransmitted_CreateAndSerializeStreamFrame_Retransmission) {
+  creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
+
+  const std::string data("test");
+  producer_.SaveStreamData(GetNthClientInitiatedStreamId(0), data);
+  EXPECT_CALL(delegate_, OnSerializedPacket(_))
+      .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
+  size_t num_bytes_consumed;
+  // Retransmission frame adds to packet's bytes_retransmitted
+  creator_.CreateAndSerializeStreamFrame(
+      GetNthClientInitiatedStreamId(0), data.length(), 0, 0, true,
+      LOSS_RETRANSMISSION, &num_bytes_consumed);
+  EXPECT_EQ(4u, num_bytes_consumed);
+
+  ASSERT_TRUE(serialized_packet_->encrypted_buffer);
+  ASSERT_FALSE(serialized_packet_->bytes_not_retransmitted.has_value());
+  DeleteSerializedPacket();
+
+  EXPECT_FALSE(creator_.HasPendingFrames());
+}
+
+TEST_P(
+    QuicPacketCreatorTest,
+    PacketBytesRetransmitted_CreateAndSerializeStreamFrame_NotRetransmission) {
+  creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
+
+  const std::string data("test");
+  producer_.SaveStreamData(GetNthClientInitiatedStreamId(0), data);
+  EXPECT_CALL(delegate_, OnSerializedPacket(_))
+      .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
+  size_t num_bytes_consumed;
+  // Non-retransmission frame does not add to packet's bytes_retransmitted
+  creator_.CreateAndSerializeStreamFrame(
+      GetNthClientInitiatedStreamId(0), data.length(), 0, 0, true,
+      NOT_RETRANSMISSION, &num_bytes_consumed);
+  EXPECT_EQ(4u, num_bytes_consumed);
+
+  ASSERT_TRUE(serialized_packet_->encrypted_buffer);
+  ASSERT_FALSE(serialized_packet_->bytes_not_retransmitted.has_value());
+  DeleteSerializedPacket();
+
+  EXPECT_FALSE(creator_.HasPendingFrames());
+}
+
 TEST_P(QuicPacketCreatorTest, RetryToken) {
   if (!GetParam().version_serialization ||
       !QuicVersionHasLongHeaderLengths(client_framer_.transport_version())) {

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

@@ -439,7 +439,8 @@ SerializedPacket::SerializedPacket(SerializedPacket&& other)
       has_ack_frequency(other.has_ack_frequency),
       has_message(other.has_message),
       fate(other.fate),
-      peer_address(other.peer_address) {
+      peer_address(other.peer_address),
+      bytes_not_retransmitted(other.bytes_not_retransmitted) {
   if (this != &other) {
     if (release_encrypted_buffer && encrypted_buffer != nullptr) {
       release_encrypted_buffer(encrypted_buffer);
@@ -486,6 +487,7 @@ SerializedPacket* CopySerializedPacket(const SerializedPacket& serialized,
   copy->has_message = serialized.has_message;
   copy->fate = serialized.fate;
   copy->peer_address = serialized.peer_address;
+  copy->bytes_not_retransmitted = serialized.bytes_not_retransmitted;
 
   if (copy_buffer) {
     copy->encrypted_buffer = CopyBuffer(serialized);

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

@@ -376,6 +376,10 @@ struct QUIC_EXPORT_PRIVATE SerializedPacket {
   bool has_message;
   SerializedPacketFate fate;
   QuicSocketAddress peer_address;
+  // Sum of bytes from frames that are not retransmissions. This field is only
+  // populated for packets with "mixed frames": at least one frame of a
+  // retransmission type and at least one frame of NOT_RETRANSMISSION type.
+  absl::optional<QuicByteCount> bytes_not_retransmitted;
 };
 
 // Make a copy of |serialized| (including the underlying frames). |copy_buffer|

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

@@ -131,17 +131,19 @@ void QuicSentPacketManager::SetFromConfig(const QuicConfig& config) {
     ignore_ack_delay_ = true;
   }
 
-  if (config.HasClientRequestedIndependentOption(kPDP1, perspective)) {
-    num_ptos_for_path_degrading_ = 1;
-  }
-  if (config.HasClientRequestedIndependentOption(kPDP2, perspective)) {
-    num_ptos_for_path_degrading_ = 2;
-  }
-  if (config.HasClientRequestedIndependentOption(kPDP3, perspective)) {
-    num_ptos_for_path_degrading_ = 3;
-  }
-  if (config.HasClientRequestedIndependentOption(kPDP5, perspective)) {
-    num_ptos_for_path_degrading_ = 5;
+  if (!remove_blackhole_detection_experiments_) {
+    if (config.HasClientRequestedIndependentOption(kPDP1, perspective)) {
+      num_ptos_for_path_degrading_ = 1;
+    }
+    if (config.HasClientRequestedIndependentOption(kPDP2, perspective)) {
+      num_ptos_for_path_degrading_ = 2;
+    }
+    if (config.HasClientRequestedIndependentOption(kPDP3, perspective)) {
+      num_ptos_for_path_degrading_ = 3;
+    }
+    if (config.HasClientRequestedIndependentOption(kPDP5, perspective)) {
+      num_ptos_for_path_degrading_ = 5;
+    }
   }
 
   // Configure congestion control.

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

@@ -26,6 +26,7 @@
 #include "quiche/quic/core/quic_types.h"
 #include "quiche/quic/core/quic_unacked_packet_map.h"
 #include "quiche/quic/platform/api/quic_export.h"
+#include "quiche/quic/platform/api/quic_flags.h"
 #include "quiche/common/quiche_circular_deque.h"
 
 namespace quic {
@@ -464,6 +465,11 @@ class QUIC_EXPORT_PRIVATE QuicSentPacketManager {
   // kMinUntrustedInitialRoundTripTimeUs if not |trusted|.
   void SetInitialRtt(QuicTime::Delta rtt, bool trusted);
 
+  // Latched value of --quic_remove_blackhole_detection_experiments.
+  bool remove_blackhole_detection_experiments() const {
+    return remove_blackhole_detection_experiments_;
+  }
+
  private:
   friend class test::QuicConnectionPeer;
   friend class test::QuicSentPacketManagerPeer;
@@ -668,6 +674,9 @@ class QUIC_EXPORT_PRIVATE QuicSentPacketManager {
 
   // Whether to ignore the ack_delay in received ACKs.
   bool ignore_ack_delay_;
+
+  const bool remove_blackhole_detection_experiments_ =
+      GetQuicReloadableFlag(quic_remove_blackhole_detection_experiments);
 };
 
 }  // namespace quic

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

@@ -2499,6 +2499,9 @@ TEST_F(QuicSentPacketManagerTest, GetPathDegradingDelayDefaultPTO) {
 }
 
 TEST_F(QuicSentPacketManagerTest, GetPathDegradingDelayUsing2PTO) {
+  if (GetQuicReloadableFlag(quic_remove_blackhole_detection_experiments)) {
+    return;
+  }
   QuicConfig client_config;
   QuicTagVector client_options;
   client_options.push_back(kPDP2);
@@ -2512,6 +2515,9 @@ TEST_F(QuicSentPacketManagerTest, GetPathDegradingDelayUsing2PTO) {
 }
 
 TEST_F(QuicSentPacketManagerTest, GetPathDegradingDelayUsing1PTO) {
+  if (GetQuicReloadableFlag(quic_remove_blackhole_detection_experiments)) {
+    return;
+  }
   QuicConfig client_config;
   QuicTagVector client_options;
   client_options.push_back(kPDP1);

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

@@ -2098,12 +2098,13 @@ void QuicSession::SendRetireConnectionId(uint64_t sequence_number) {
   control_frame_manager_.WriteOrBufferRetireConnectionId(sequence_number);
 }
 
-void QuicSession::OnServerConnectionIdIssued(
+bool QuicSession::MaybeReserveConnectionId(
     const QuicConnectionId& server_connection_id) {
   if (visitor_) {
-    visitor_->OnNewConnectionIdSent(
+    return visitor_->TryAddNewConnectionId(
         connection_->GetOneActiveServerConnectionId(), server_connection_id);
   }
+  return true;
 }
 
 void QuicSession::OnServerConnectionIdRetired(

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

@@ -89,8 +89,8 @@ class QUIC_EXPORT_PRIVATE QuicSession
     // peer.
     virtual void OnStopSendingReceived(const QuicStopSendingFrame& frame) = 0;
 
-    // Called when a NewConnectionId frame has been sent.
-    virtual void OnNewConnectionIdSent(
+    // Called when on whether a NewConnectionId frame can been sent.
+    virtual bool TryAddNewConnectionId(
         const QuicConnectionId& server_connection_id,
         const QuicConnectionId& new_connection_id) = 0;
 
@@ -145,7 +145,12 @@ class QUIC_EXPORT_PRIVATE QuicSession
   void SendAckFrequency(const QuicAckFrequencyFrame& frame) override;
   void SendNewConnectionId(const QuicNewConnectionIdFrame& frame) override;
   void SendRetireConnectionId(uint64_t sequence_number) override;
-  void OnServerConnectionIdIssued(
+  // Returns true if server_connection_id can be issued. If returns true,
+  // |visitor_| may establish a mapping from |server_connection_id| to this
+  // session, if that's not desired,
+  // OnServerConnectionIdRetired(server_connection_id) can be used to remove the
+  // mapping.
+  bool MaybeReserveConnectionId(
       const QuicConnectionId& server_connection_id) override;
   void OnServerConnectionIdRetired(
       const QuicConnectionId& server_connection_id) override;

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

@@ -307,6 +307,24 @@ std::ostream& operator<<(std::ostream& os, SerializedPacketFate fate) {
   return os;
 }
 
+std::string CongestionControlTypeToString(CongestionControlType cc_type) {
+  switch (cc_type) {
+    case kCubicBytes:
+      return "CUBIC_BYTES";
+    case kRenoBytes:
+      return "RENO_BYTES";
+    case kBBR:
+      return "BBR";
+    case kBBRv2:
+      return "BBRv2";
+    case kPCC:
+      return "PCC";
+    case kGoogCC:
+      return "GoogCC";
+  }
+  return absl::StrCat("Unknown(", static_cast<int>(cc_type), ")");
+}
+
 std::string EncryptionLevelToString(EncryptionLevel level) {
   switch (level) {
     RETURN_STRING_LITERAL(ENCRYPTION_INITIAL);

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

@@ -452,6 +452,9 @@ enum CongestionControlType {
   kBBRv2,
 };
 
+QUIC_EXPORT_PRIVATE std::string CongestionControlTypeToString(
+    CongestionControlType cc_type);
+
 // EncryptionLevel enumerates the stages of encryption that a QUIC connection
 // progresses through. When retransmitting a packet, the encryption level needs
 // to be specified so that it is retransmitted at a level which the peer can

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

@@ -267,6 +267,9 @@ void TlsChloExtractor::SendAlert(uint8_t tls_alert_value) {
   HandleUnrecoverableError(absl::StrCat(
       "BoringSSL attempted to send alert ", static_cast<int>(tls_alert_value),
       " ", SSL_alert_desc_string_long(tls_alert_value)));
+  if (state_ == State::kUnrecoverableFailure) {
+    tls_alert_ = tls_alert_value;
+  }
 }
 
 // static

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

@@ -62,6 +62,13 @@ class QUIC_NO_EXPORT TlsChloExtractor
            state_ == State::kParsedFullMultiPacketChlo;
   }
 
+  // Returns the TLS alert that caused the unrecoverable error, if any.
+  absl::optional<uint8_t> tls_alert() const {
+    QUICHE_DCHECK(!tls_alert_.has_value() ||
+                  state_ == State::kUnrecoverableFailure);
+    return tls_alert_;
+  }
+
   // Methods from QuicFramerVisitorInterface.
   void OnError(QuicFramer* /*framer*/) override {}
   bool OnProtocolVersionMismatch(ParsedQuicVersion version) override;
@@ -249,6 +256,9 @@ class QUIC_NO_EXPORT TlsChloExtractor
   // Whether early data is attempted from the CHLO, indicated by the
   // 'early_data' TLS extension.
   bool early_data_attempted_ = false;
+  // If set, contains the TLS alert that caused an unrecoverable error, which is
+  // an AlertDescription value defined in go/rfc/8446#appendix-B.2.
+  absl::optional<uint8_t> tls_alert_;
 };
 
 // Convenience method to facilitate logging TlsChloExtractor::State.

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

@@ -27,7 +27,7 @@ class MockQuicSessionVisitor : public QuicTimeWaitListManager::Visitor {
               (override));
   MOCK_METHOD(void, OnStopSendingReceived, (const QuicStopSendingFrame& frame),
               (override));
-  MOCK_METHOD(void, OnNewConnectionIdSent,
+  MOCK_METHOD(bool, TryAddNewConnectionId,
               (const QuicConnectionId& server_connection_id,
                const QuicConnectionId& new_connection_id),
               (override));

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

@@ -475,7 +475,7 @@ class MockQuicConnectionVisitor : public QuicConnectionVisitorInterface {
               (const QuicNewConnectionIdFrame& frame), (override));
   MOCK_METHOD(void, SendRetireConnectionId, (uint64_t sequence_number),
               (override));
-  MOCK_METHOD(void, OnServerConnectionIdIssued,
+  MOCK_METHOD(bool, MaybeReserveConnectionId,
               (const QuicConnectionId& server_connection_id), (override));
   MOCK_METHOD(void, OnServerConnectionIdRetired,
               (const QuicConnectionId& server_connection_id), (override));

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

@@ -27,8 +27,9 @@ void ServerThread::Initialize() {
   if (initialized_) {
     return;
   }
-
-  server_->CreateUDPSocketAndListen(address_);
+  if (!server_->CreateUDPSocketAndListen(address_)) {
+    return;
+  }
 
   QuicWriterMutexLock lock(&port_lock_);
   port_ = server_->port();

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

@@ -37,6 +37,12 @@ SimpleSessionNotifier::StreamState::~StreamState() {}
 
 QuicConsumedData SimpleSessionNotifier::WriteOrBufferData(
     QuicStreamId id, QuicByteCount data_length, StreamSendingState state) {
+  return WriteOrBufferData(id, data_length, state, NOT_RETRANSMISSION);
+}
+
+QuicConsumedData SimpleSessionNotifier::WriteOrBufferData(
+    QuicStreamId id, QuicByteCount data_length, StreamSendingState state,
+    TransmissionType transmission_type) {
   if (!stream_map_.contains(id)) {
     stream_map_[id] = StreamState();
   }
@@ -53,7 +59,7 @@ QuicConsumedData SimpleSessionNotifier::WriteOrBufferData(
     return {0, false};
   }
   const size_t length = stream_state.bytes_total - stream_state.bytes_sent;
-  connection_->SetTransmissionType(NOT_RETRANSMISSION);
+  connection_->SetTransmissionType(transmission_type);
   QuicConsumedData consumed =
       connection_->SendStreamData(id, length, stream_state.bytes_sent, state);
   QUIC_DVLOG(1) << "consumed: " << consumed;

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

@@ -28,6 +28,9 @@ class SimpleSessionNotifier : public SessionNotifierInterface {
   // Tries to write stream data and returns data consumed.
   QuicConsumedData WriteOrBufferData(QuicStreamId id, QuicByteCount data_length,
                                      StreamSendingState state);
+  QuicConsumedData WriteOrBufferData(QuicStreamId id, QuicByteCount data_length,
+                                     StreamSendingState state,
+                                     TransmissionType transmission_type);
 
   // Tries to write RST_STREAM_FRAME.
   void WriteOrBufferRstStream(QuicStreamId id, QuicRstStreamErrorCode error,

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

@@ -74,8 +74,10 @@ class QuicEndpoint : public QuicEndpointBase,
   void SendNewConnectionId(const QuicNewConnectionIdFrame& /*frame*/) override {
   }
   void SendRetireConnectionId(uint64_t /*sequence_number*/) override {}
-  void OnServerConnectionIdIssued(
-      const QuicConnectionId& /*server_connection_id*/) override {}
+  bool MaybeReserveConnectionId(
+      const QuicConnectionId& /*server_connection_id*/) override {
+    return true;
+  }
   void OnServerConnectionIdRetired(
       const QuicConnectionId& /*server_connection_id*/) override {}
   bool AllowSelfAddressChange() const override;

package/certs/ca.cnf

@@ -1,69 +0,0 @@
-# Defaults in the event they're not set in the environment
-CA_DIR    = out
-KEY_SIZE  = 2048
-ALGO      = sha256
-CERT_TYPE = root
-CA_NAME   = req_env_dn
-[ca]
-default_ca = CA_root
-preserve   = yes
-# The default test root, used to generate certificates and CRLs.
-[CA_root]
-dir           = $ENV::CA_DIR
-key_size      = $ENV::KEY_SIZE
-algo          = $ENV::ALGO
-cert_type     = $ENV::CERT_TYPE
-type          = $key_size-$algo-$cert_type
-database      = $dir/$type-index.txt
-new_certs_dir = $dir
-serial        = $dir/$type-serial
-certificate   = $dir/$type.pem
-private_key   = $dir/$type.key
-RANDFILE      = $dir/.rand
-default_days     = 3650
-default_crl_days = 30
-default_md       = sha256
-policy           = policy_anything
-unique_subject   = no
-copy_extensions  = copy
-[user_cert]
-# Extensions to add when signing a request for an EE cert
-basicConstraints       = critical, CA:false
-subjectKeyIdentifier   = hash
-authorityKeyIdentifier = keyid:always
-extendedKeyUsage       = serverAuth,clientAuth
-[ca_cert]
-# Extensions to add when signing a request for an intermediate/CA cert
-basicConstraints       = critical, CA:true
-subjectKeyIdentifier   = hash
-keyUsage               = critical, keyCertSign, cRLSign
-[crl_extensions]
-# Extensions to add when signing a CRL
-authorityKeyIdentifier = keyid:always
-[policy_anything]
-# Default signing policy
-countryName            = optional
-stateOrProvinceName    = optional
-localityName           = optional
-organizationName       = optional
-organizationalUnitName = optional
-commonName             = optional
-emailAddress           = optional
-[req]
-# The request section used to generate the root CA certificate. This should
-# not be used to generate end-entity certificates. For certificates other
-# than the root CA, see README to find the appropriate configuration file
-# (ie: openssl_cert.cnf).
-default_bits       = $ENV::KEY_SIZE
-default_md         = sha256
-string_mask        = utf8only
-prompt             = no
-encrypt_key        = no
-distinguished_name = $ENV::CA_NAME
-x509_extensions    = req_ca_exts
-[req_env_dn]
-CN = FAILS Server Root CA
-[req_ca_exts]
-basicConstraints       = critical, CA:true
-keyUsage               = critical, keyCertSign, cRLSign
-subjectKeyIdentifier   = hash

package/certs/generate_certs.sh

@@ -1,53 +0,0 @@
-#!/bin/sh
-# Copyright 2015 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.
-# This script generates a CA and leaf cert which can be used for the
-# quic_server.
-try() {
-  "$@" || (e=$?; echo "$@" > /dev/stderr; exit $e)
-}
-try rm -rf out
-try mkdir out
-try /bin/sh -c "echo 01 > out/2048-sha256-root-serial"
-touch out/2048-sha256-root-index.txt
-# Generate the key.
-try openssl genrsa -out out/2048-sha256-root.key 2048
-# Generate the root certificate.
-try openssl req \
-  -new \
-  -key out/2048-sha256-root.key \
-  -out out/2048-sha256-root.req \
-  -config ca.cnf
-try openssl x509 \
-  -req -days 365 \
-  -in out/2048-sha256-root.req \
-  -signkey out/2048-sha256-root.key \
-  -extfile ca.cnf \
-  -extensions ca_cert \
-  -text > out/2048-sha256-root.pem
-# Generate the leaf certificate request.
-try openssl req \
-  -new \
-  -keyout out/leaf_cert.key \
-  -out out/leaf_cert.req \
-  -config leaf.cnf
-# Convert the key to pkcs8.
-try openssl pkcs8 \
-  -topk8 \
-  -outform DER \
-  -inform PEM \
-  -in out/leaf_cert.key \
-  -out out/leaf_cert.pkcs8 \
-  -nocrypt
-# Generate the leaf certificate to be valid for 365 days.
-try openssl ca \
-  -batch \
-  -days 365 \
-  -extensions user_cert \
-  -in out/leaf_cert.req \
-  -out out/leaf_cert.pem \
-  -config ca.cnf
-
-  # TODO
-try openssl x509 -in out/leaf_cert.pem -pubkey -noout | openssl pkey -pubin -outform der | openssl dgst -sha256 -binary | openssl enc -base64 > out/fingerprint.txt

package/certs/generate_certs_leaf.sh

@@ -1,53 +0,0 @@
-#!/bin/sh
-# Copyright 2015 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.
-# This script generates a CA and leaf cert which can be used for the
-# quic_server.
-try() {
-  "$@" || (e=$?; echo "$@" > /dev/stderr; exit $e)
-}
-#try rm -rf out
-try mkdir out
-try /bin/sh -c "echo 01 > out/2048-sha256-root-serial"
-touch out/2048-sha256-root-index.txt
-# Generate the key.
-#try openssl genrsa -out out/2048-sha256-root.key 2048
-# Generate the root certificate.
-#try openssl req \
-#  -new \
-#  -key out/2048-sha256-root.key \
-#  -out out/2048-sha256-root.req \
-#  -config ca.cnf
-#try openssl x509 \
-#  -req -days 365 \
-#  -in out/2048-sha256-root.req \
-#  -signkey out/2048-sha256-root.key \
-#  -extfile ca.cnf \
-#  -extensions ca_cert \
-#  -text > out/2048-sha256-root.pem
-# Generate the leaf certificate request.
-try openssl req \
-  -new \
-  -keyout out/leaf_cert.key \
-  -out out/leaf_cert.req \
-  -config leaf.cnf
-# Convert the key to pkcs8.
-try openssl pkcs8 \
-  -topk8 \
-  -outform DER \
-  -inform PEM \
-  -in out/leaf_cert.key \
-  -out out/leaf_cert.pkcs8 \
-  -nocrypt
-# Generate the leaf certificate to be valid for 365 days.
-try openssl ca \
-  -batch \
-  -days 365 \
-  -extensions user_cert \
-  -in out/leaf_cert.req \
-  -out out/leaf_cert.pem \
-  -config ca.cnf
-
-  # TODO
-try openssl x509 -in out/leaf_cert.pem -pubkey -noout | openssl pkey -pubin -outform der | openssl dgst -sha256 -binary | openssl enc -base64 > out/fingerprint.txt