blob: 336ca142439e28ed4e9b8aca3cb0ebbce9ab0748 [file] [log] [blame]
// Copyright (c) 2017 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/third_party/quiche/src/quic/quartc/quartc_factory.h"
#include "net/third_party/quiche/src/quic/core/crypto/quic_random.h"
#include "net/third_party/quiche/src/quic/core/quic_utils.h"
#include "net/third_party/quiche/src/quic/core/tls_client_handshaker.h"
#include "net/third_party/quiche/src/quic/core/tls_server_handshaker.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
#include "net/third_party/quiche/src/quic/quartc/quartc_connection_helper.h"
#include "net/third_party/quiche/src/quic/quartc/quartc_crypto_helpers.h"
#include "net/third_party/quiche/src/quic/quartc/quartc_session.h"
namespace quic {
QuartcFactory::QuartcFactory(const QuartcFactoryConfig& factory_config)
: alarm_factory_(factory_config.alarm_factory),
clock_(factory_config.clock),
connection_helper_(QuicMakeUnique<QuartcConnectionHelper>(clock_)),
compressed_certs_cache_(QuicMakeUnique<QuicCompressedCertsCache>(
QuicCompressedCertsCache::kQuicCompressedCertsCacheSize)),
stream_helper_(QuicMakeUnique<QuartcCryptoServerStreamHelper>()) {}
std::unique_ptr<QuartcSession> QuartcFactory::CreateQuartcClientSession(
const QuartcSessionConfig& quartc_session_config,
QuicStringPiece server_crypto_config) {
DCHECK(quartc_session_config.packet_transport);
// QuartcSession will eventually own both |writer| and |quic_connection|.
auto writer =
QuicMakeUnique<QuartcPacketWriter>(quartc_session_config.packet_transport,
quartc_session_config.max_packet_size);
// While the QuicConfig is not directly used by the connection, creating it
// also sets flag values which must be set before creating the connection.
QuicConfig quic_config = CreateQuicConfig(quartc_session_config);
std::unique_ptr<QuicConnection> quic_connection =
CreateQuicConnection(Perspective::IS_CLIENT, writer.get());
return QuicMakeUnique<QuartcClientSession>(
std::move(quic_connection), quic_config, CurrentSupportedVersions(),
clock_, std::move(writer),
CreateCryptoClientConfig(quartc_session_config.pre_shared_key),
server_crypto_config);
}
QuicConfig CreateQuicConfig(const QuartcSessionConfig& quartc_session_config) {
// TODO(b/124398962): Figure out a better way to initialize QUIC flags.
// Creating a config shouldn't have global side-effects on flags. However,
// this has the advantage of ensuring that flag values stay in sync with the
// options requested by configs, so simply splitting the config and flag
// settings doesn't seem preferable.
// Fixes behavior of StopReading() with level-triggered stream sequencers.
SetQuicReloadableFlag(quic_stop_reading_when_level_triggered, true);
// Fix b/110259444.
SetQuicReloadableFlag(quic_fix_spurious_ack_alarm, true);
// Enable version 46+ to enable SendMessage API and 'quic bit' per draft 17.
SetQuicReloadableFlag(quic_enable_version_46, true);
// Fix for inconsistent reporting of crypto handshake.
SetQuicReloadableFlag(quic_fix_has_pending_crypto_data, true);
// Ensure that we don't drop data because QUIC streams refuse to buffer it.
// TODO(b/120099046): Replace this with correct handling of WriteMemSlices().
SetQuicFlag(&FLAGS_quic_buffered_data_threshold,
std::numeric_limits<int>::max());
// TODO(b/117157454): Perform version negotiation for Quartc outside of
// QuicSession/QuicConnection. Currently default of
// gfe2_restart_flag_quic_no_server_conn_ver_negotiation2 is false,
// but we fail blueprint test that sets all QUIC flags to true.
//
// Forcing flag to false to pass blueprint tests, but eventually we'll have
// to implement negotiation outside of QuicConnection.
SetQuicRestartFlag(quic_no_server_conn_ver_negotiation2, false);
QuicTagVector copt;
copt.push_back(kNSTP);
// Enable and request QUIC to include receive timestamps in ACK frames.
SetQuicReloadableFlag(quic_send_timestamps, true);
copt.push_back(kSTMP);
// Enable ACK_DECIMATION_WITH_REORDERING. It requires ack_decimation to be
// false.
SetQuicReloadableFlag(quic_enable_ack_decimation, false);
copt.push_back(kAKD2);
// Use unlimited decimation in order to reduce number of unbundled ACKs.
copt.push_back(kAKDU);
// Enable time-based loss detection.
copt.push_back(kTIME);
// Note: flag settings have no effect for Exoblaze builds since
// SetQuicReloadableFlag() gets stubbed out.
SetQuicReloadableFlag(quic_bbr_less_probe_rtt, true); // Enable BBR6,7,8.
SetQuicReloadableFlag(quic_unified_iw_options, true); // Enable IWXX opts.
SetQuicReloadableFlag(quic_bbr_slower_startup3, true); // Enable BBQX opts.
SetQuicReloadableFlag(quic_bbr_flexible_app_limited, true); // Enable BBR9.
copt.push_back(kBBR3); // Stay in low-gain until in-flight < BDP.
copt.push_back(kBBR5); // 40 RTT ack aggregation.
copt.push_back(kBBR6); // Use a 0.75 * BDP cwnd during PROBE_RTT.
copt.push_back(kBBR8); // Skip PROBE_RTT if app-limited.
copt.push_back(kBBR9); // Ignore app-limited if enough data is in flight.
copt.push_back(kBBQ1); // 2.773 pacing gain in STARTUP.
copt.push_back(kBBQ2); // 2.0 CWND gain in STARTUP.
copt.push_back(kBBQ4); // 0.75 pacing gain in DRAIN.
copt.push_back(k1RTT); // Exit STARTUP after 1 RTT with no gains.
copt.push_back(kIW10); // 10-packet (14600 byte) initial cwnd.
if (!quartc_session_config.enable_tail_loss_probe) {
copt.push_back(kNTLP);
}
// TODO(b/112192153): Test and possible enable slower startup when pipe
// filling is ready to use. Slower startup is kBBRS.
QuicConfig quic_config;
// Use the limits for the session & stream flow control. The default 16KB
// limit leads to significantly undersending (not reaching BWE on the outgoing
// bitrate) due to blocked frames, and it leads to high latency (and one-way
// delay). Setting it to its limits is not going to cause issues (our streams
// are small generally, and if we were to buffer 24MB it wouldn't be the end
// of the world). We can consider setting different limits in future (e.g. 1MB
// stream, 1.5MB session). It's worth noting that on 1mbps bitrate, limit of
// 24MB can capture approx 4 minutes of the call, and the default increase in
// size of the window (half of the window size) is approximately 2 minutes of
// the call.
quic_config.SetInitialSessionFlowControlWindowToSend(
kSessionReceiveWindowLimit);
quic_config.SetInitialStreamFlowControlWindowToSend(
kStreamReceiveWindowLimit);
quic_config.SetConnectionOptionsToSend(copt);
quic_config.SetClientConnectionOptions(copt);
if (quartc_session_config.max_time_before_crypto_handshake >
QuicTime::Delta::Zero()) {
quic_config.set_max_time_before_crypto_handshake(
quartc_session_config.max_time_before_crypto_handshake);
}
if (quartc_session_config.max_idle_time_before_crypto_handshake >
QuicTime::Delta::Zero()) {
quic_config.set_max_idle_time_before_crypto_handshake(
quartc_session_config.max_idle_time_before_crypto_handshake);
}
if (quartc_session_config.idle_network_timeout > QuicTime::Delta::Zero()) {
quic_config.SetIdleNetworkTimeout(
quartc_session_config.idle_network_timeout,
quartc_session_config.idle_network_timeout);
}
// The ICE transport provides a unique 5-tuple for each connection. Save
// overhead by omitting the connection id.
quic_config.SetBytesForConnectionIdToSend(0);
// Allow up to 1000 incoming streams at once. Quartc streams typically contain
// one audio or video frame and close immediately. However, when a video frame
// becomes larger than one packet, there is some delay between the start and
// end of each stream. The default maximum of 100 only leaves about 1 second
// of headroom (Quartc sends ~30 video frames per second) before QUIC starts
// to refuse incoming streams. Back-pressure should clear backlogs of
// incomplete streams, but targets 1 second for recovery. Increasing the
// number of open streams gives sufficient headroom to recover before QUIC
// refuses new streams.
quic_config.SetMaxIncomingDynamicStreamsToSend(1000);
return quic_config;
}
std::unique_ptr<QuicConnection> QuartcFactory::CreateQuicConnection(
Perspective perspective,
QuartcPacketWriter* packet_writer) {
// |dummy_id| and |dummy_address| are used because Quartc network layer will
// not use these two.
char connection_id_bytes[sizeof(uint64_t)] = {};
QuicConnectionId dummy_id = QuicConnectionId(
static_cast<char*>(connection_id_bytes), sizeof(connection_id_bytes));
QuicSocketAddress dummy_address(QuicIpAddress::Any4(), /*port=*/0);
return quic::CreateQuicConnection(
dummy_id, dummy_address, connection_helper_.get(), alarm_factory_,
packet_writer, perspective, CurrentSupportedVersions());
}
std::unique_ptr<QuicConnection> CreateQuicConnection(
QuicConnectionId connection_id,
const QuicSocketAddress& peer_address,
QuicConnectionHelperInterface* connection_helper,
QuicAlarmFactory* alarm_factory,
QuicPacketWriter* packet_writer,
Perspective perspective,
ParsedQuicVersionVector supported_versions) {
auto quic_connection = QuicMakeUnique<QuicConnection>(
connection_id, peer_address, connection_helper, alarm_factory,
packet_writer,
/*owns_writer=*/false, perspective, supported_versions);
QuicSentPacketManager& sent_packet_manager =
quic_connection->sent_packet_manager();
// Default delayed ack time is 25ms.
// If data packets are sent less often (e.g. because p-time was modified),
// we would force acks to be sent every 25ms regardless, increasing
// overhead. Since generally we guarantee a packet every 20ms, changing
// this value should have miniscule effect on quality on good connections,
// but on poor connections, changing this number significantly reduced the
// number of ack-only packets.
// The p-time can go up to as high as 120ms, and when it does, it's
// when the low overhead is the most important thing. Ideally it should be
// above 120ms, but it cannot be higher than 0.5*RTO, which equals to 100ms.
sent_packet_manager.set_delayed_ack_time(
QuicTime::Delta::FromMilliseconds(100));
quic_connection->set_fill_up_link_during_probing(true);
// We start ack decimation after 15 packets. Typically, we would see
// 1-2 crypto handshake packets, one media packet, and 10 probing packets.
// We want to get acks for the probing packets as soon as possible,
// but we can start using ack decimation right after first probing completes.
// The default was to not start ack decimation for the first 100 packets.
quic_connection->set_min_received_before_ack_decimation(15);
return quic_connection;
}
std::unique_ptr<QuartcFactory> CreateQuartcFactory(
const QuartcFactoryConfig& factory_config) {
return std::unique_ptr<QuartcFactory>(new QuartcFactory(factory_config));
}
} // namespace quic