Make QUICHE command-line flags use a different function to get value than the regular feature flags.
This makes command-line flags possible to work in Envoy.
PiperOrigin-RevId: 450746605
diff --git a/quiche/balsa/balsa_frame_test.cc b/quiche/balsa/balsa_frame_test.cc
index ecf7454..1ce4c7b 100644
--- a/quiche/balsa/balsa_frame_test.cc
+++ b/quiche/balsa/balsa_frame_test.cc
@@ -2251,7 +2251,7 @@
TEST(HTTPBalsaFrame,
VisitorInvokedProperlyForResponseWithTransferEncodingAndTrailersRandom) {
TestSeed seed;
- seed.Initialize(GetQuicheFlag(FLAGS_randseed));
+ seed.Initialize(GetQuicheCommandLineFlag(FLAGS_randseed));
RandomEngine rng;
rng.seed(seed.GetSeed());
for (int i = 0; i < 1000; ++i) {
@@ -3172,7 +3172,7 @@
std::map<std::string, std::string>::const_iterator iter;
std::string trailer_data;
TestSeed seed;
- seed.Initialize(GetQuicheFlag(FLAGS_randseed));
+ seed.Initialize(GetQuicheCommandLineFlag(FLAGS_randseed));
RandomEngine rng;
rng.seed(seed.GetSeed());
FakeHeaders fake_headers_in_trailer;
diff --git a/quiche/common/platform/api/quiche_command_line_flags.h b/quiche/common/platform/api/quiche_command_line_flags.h
index 783dea6..57caeb3 100644
--- a/quiche/common/platform/api/quiche_command_line_flags.h
+++ b/quiche/common/platform/api/quiche_command_line_flags.h
@@ -11,12 +11,17 @@
#include "quiche_platform_impl/quiche_command_line_flags_impl.h"
// Define a command-line flag that can be automatically set via
-// QuicheParseCommandLineFlags().
+// QuicheParseCommandLineFlags(). The macro has to be called in the .cc file of
+// a unit test or the CLI tool reading the flag.
#define DEFINE_QUICHE_COMMAND_LINE_FLAG(type, name, default_value, help) \
DEFINE_QUICHE_COMMAND_LINE_FLAG_IMPL(type, name, default_value, help)
namespace quiche {
+// The impl header must provide GetQuicheCommandLineFlag(), which takes
+// PlatformSpecificFlag<T> variable defined by the macro above, and returns the
+// flag value of type T.
+
// Parses command-line flags, setting flag variables defined using
// DEFINE_QUICHE_COMMAND_LINE_FLAG if they appear in the command line, and
// returning a list of any non-flag arguments specified in the command line. If
diff --git a/quiche/common/platform/api/quiche_flags.h b/quiche/common/platform/api/quiche_flags.h
index e039b1f..26a933c 100644
--- a/quiche/common/platform/api/quiche_flags.h
+++ b/quiche/common/platform/api/quiche_flags.h
@@ -8,6 +8,9 @@
#include "quiche_platform_impl/quic_flags_impl.h"
#include "quiche_platform_impl/quiche_flags_impl.h"
+// Flags accessed via GetQuicheReloadableFlag/GetQuicheRestartFlag are temporary
+// boolean flags that are used to enable or disable code behavior changes. The
+// current list is available in the quiche/quic/core/quic_flags_list.h file.
#define GetQuicheReloadableFlag(module, flag) \
GetQuicheReloadableFlagImpl(module, flag)
#define SetQuicheReloadableFlag(module, flag, value) \
@@ -16,6 +19,10 @@
GetQuicheRestartFlagImpl(module, flag)
#define SetQuicheRestartFlag(module, flag, value) \
SetQuicheRestartFlagImpl(module, flag, value)
+
+// Flags accessed via GetQuicheFlag are permanent flags used to control QUICHE
+// library behavior. The current list is available in the
+// quiche/quic/core/quic_protocol_flags_list.h file.
#define GetQuicheFlag(flag) GetQuicheFlagImpl(flag)
#define SetQuicheFlag(flag, value) SetQuicheFlagImpl(flag, value)
diff --git a/quiche/common/platform/default/quiche_platform_impl/quiche_command_line_flags_impl.h b/quiche/common/platform/default/quiche_platform_impl/quiche_command_line_flags_impl.h
index e0ccf17..d9f7bac 100644
--- a/quiche/common/platform/default/quiche_platform_impl/quiche_command_line_flags_impl.h
+++ b/quiche/common/platform/default/quiche_platform_impl/quiche_command_line_flags_impl.h
@@ -12,6 +12,11 @@
namespace quiche {
+template <typename T>
+T GetQuicheCommandLineFlag(const absl::Flag<T>& flag) {
+ return absl::GetFlag(flag);
+}
+
std::vector<std::string> QuicheParseCommandLineFlagsImpl(
const char* usage, int argc, const char* const* argv,
bool parse_only = false);
diff --git a/quiche/quic/core/congestion_control/bbr2_simulator_test.cc b/quiche/quic/core/congestion_control/bbr2_simulator_test.cc
index 6a0e581..fdf036b 100644
--- a/quiche/quic/core/congestion_control/bbr2_simulator_test.cc
+++ b/quiche/quic/core/congestion_control/bbr2_simulator_test.cc
@@ -127,7 +127,8 @@
}
void SetUp() override {
- if (GetQuicFlag(FLAGS_quic_bbr2_test_regression_mode) == "regress") {
+ if (quiche::GetQuicheCommandLineFlag(
+ FLAGS_quic_bbr2_test_regression_mode) == "regress") {
SendAlgorithmTestResult expected;
ASSERT_TRUE(LoadSendAlgorithmTestResult(&expected));
random_seed_ = expected.random_seed();
@@ -140,7 +141,7 @@
~Bbr2SimulatorTest() override {
const std::string regression_mode =
- GetQuicFlag(FLAGS_quic_bbr2_test_regression_mode);
+ quiche::GetQuicheCommandLineFlag(FLAGS_quic_bbr2_test_regression_mode);
const QuicTime::Delta simulated_duration =
SimulatedNow() - QuicTime::Zero();
if (regression_mode == "record") {
diff --git a/quiche/quic/core/congestion_control/bbr_sender_test.cc b/quiche/quic/core/congestion_control/bbr_sender_test.cc
index 199d322..bbdbee6 100644
--- a/quiche/quic/core/congestion_control/bbr_sender_test.cc
+++ b/quiche/quic/core/congestion_control/bbr_sender_test.cc
@@ -108,7 +108,8 @@
}
void SetUp() override {
- if (GetQuicFlag(FLAGS_quic_bbr_test_regression_mode) == "regress") {
+ if (quiche::GetQuicheCommandLineFlag(FLAGS_quic_bbr_test_regression_mode) ==
+ "regress") {
SendAlgorithmTestResult expected;
ASSERT_TRUE(LoadSendAlgorithmTestResult(&expected));
random_seed_ = expected.random_seed();
@@ -121,7 +122,7 @@
~BbrSenderTest() {
const std::string regression_mode =
- GetQuicFlag(FLAGS_quic_bbr_test_regression_mode);
+ quiche::GetQuicheCommandLineFlag(FLAGS_quic_bbr_test_regression_mode);
const QuicTime::Delta simulated_duration = clock_->Now() - QuicTime::Zero();
if (regression_mode == "record") {
RecordSendAlgorithmTestResult(random_seed_,
diff --git a/quiche/quic/masque/masque_client_bin.cc b/quiche/quic/masque/masque_client_bin.cc
index 0868e7d..2d686df 100644
--- a/quiche/quic/masque/masque_client_bin.cc
+++ b/quiche/quic/masque/masque_client_bin.cc
@@ -54,7 +54,7 @@
}
const bool disable_certificate_verification =
- GetQuicFlag(FLAGS_disable_certificate_verification);
+ quiche::GetQuicheCommandLineFlag(FLAGS_disable_certificate_verification);
QuicEpollServer epoll_server;
std::string uri_template = urls[0];
@@ -84,7 +84,7 @@
proof_verifier = CreateDefaultProofVerifier(host);
}
MasqueMode masque_mode = MasqueMode::kOpen;
- std::string mode_string = GetQuicFlag(FLAGS_masque_mode);
+ std::string mode_string = quiche::GetQuicheCommandLineFlag(FLAGS_masque_mode);
if (!mode_string.empty() && mode_string != "open") {
std::cerr << "Invalid masque_mode \"" << mode_string << "\"" << std::endl;
return 1;
diff --git a/quiche/quic/masque/masque_server_bin.cc b/quiche/quic/masque/masque_server_bin.cc
index bae882f..23d9d69 100644
--- a/quiche/quic/masque/masque_server_bin.cc
+++ b/quiche/quic/masque/masque_server_bin.cc
@@ -46,21 +46,22 @@
}
quic::MasqueMode masque_mode = quic::MasqueMode::kOpen;
- std::string mode_string = GetQuicFlag(FLAGS_masque_mode);
+ std::string mode_string = quiche::GetQuicheCommandLineFlag(FLAGS_masque_mode);
if (!mode_string.empty() && mode_string != "open") {
std::cerr << "Invalid masque_mode \"" << mode_string << "\"" << std::endl;
return 1;
}
auto backend = std::make_unique<quic::MasqueServerBackend>(
- masque_mode, GetQuicFlag(FLAGS_server_authority),
- GetQuicFlag(FLAGS_cache_dir));
+ masque_mode, quiche::GetQuicheCommandLineFlag(FLAGS_server_authority),
+ quiche::GetQuicheCommandLineFlag(FLAGS_cache_dir));
auto server =
std::make_unique<quic::MasqueEpollServer>(masque_mode, backend.get());
if (!server->CreateUDPSocketAndListen(quic::QuicSocketAddress(
- quic::QuicIpAddress::Any6(), GetQuicFlag(FLAGS_port)))) {
+ quic::QuicIpAddress::Any6(),
+ quiche::GetQuicheCommandLineFlag(FLAGS_port)))) {
return 1;
}
diff --git a/quiche/quic/qbone/qbone_client_session.cc b/quiche/quic/qbone/qbone_client_session.cc
index 4c22d23..cfc6001 100644
--- a/quiche/quic/qbone/qbone_client_session.cc
+++ b/quiche/quic/qbone/qbone_client_session.cc
@@ -58,7 +58,8 @@
QboneSessionBase::Initialize();
static_cast<QuicCryptoClientStreamBase*>(GetMutableCryptoStream())
->CryptoConnect();
- if (!GetQuicFlag(FLAGS_qbone_client_defer_control_stream_creation)) {
+ if (!quiche::GetQuicheCommandLineFlag(
+ FLAGS_qbone_client_defer_control_stream_creation)) {
CreateControlStream();
}
}
@@ -66,7 +67,8 @@
void QboneClientSession::SetDefaultEncryptionLevel(
quic::EncryptionLevel level) {
QboneSessionBase::SetDefaultEncryptionLevel(level);
- if (GetQuicFlag(FLAGS_qbone_client_defer_control_stream_creation) &&
+ if (quiche::GetQuicheCommandLineFlag(
+ FLAGS_qbone_client_defer_control_stream_creation) &&
level == quic::ENCRYPTION_FORWARD_SECURE) {
CreateControlStream();
}
diff --git a/quiche/quic/qbone/qbone_server_session.cc b/quiche/quic/qbone/qbone_server_session.cc
index 6f189e7..c6d622f 100644
--- a/quiche/quic/qbone/qbone_server_session.cc
+++ b/quiche/quic/qbone/qbone_server_session.cc
@@ -79,7 +79,8 @@
void QboneServerSession::Initialize() {
QboneSessionBase::Initialize();
- if (!GetQuicFlag(FLAGS_qbone_server_defer_control_stream_creation)) {
+ if (!quiche::GetQuicheCommandLineFlag(
+ FLAGS_qbone_server_defer_control_stream_creation)) {
CreateControlStream();
}
}
@@ -87,7 +88,8 @@
void QboneServerSession::SetDefaultEncryptionLevel(
quic::EncryptionLevel level) {
QboneSessionBase::SetDefaultEncryptionLevel(level);
- if (GetQuicFlag(FLAGS_qbone_server_defer_control_stream_creation) &&
+ if (quiche::GetQuicheCommandLineFlag(
+ FLAGS_qbone_server_defer_control_stream_creation) &&
level == quic::ENCRYPTION_FORWARD_SECURE) {
CreateControlStream();
}
diff --git a/quiche/quic/qbone/qbone_session_base.cc b/quiche/quic/qbone/qbone_session_base.cc
index 3755bb5..36517b7 100644
--- a/quiche/quic/qbone/qbone_session_base.cc
+++ b/quiche/quic/qbone/qbone_session_base.cc
@@ -75,7 +75,7 @@
flow_controller()->AddBytesConsumed(frame.data_length);
// TODO(b/147817422): Add a counter for how many streams were actually
// closed here.
- if (GetQuicFlag(FLAGS_qbone_close_ephemeral_frames)) {
+ if (quiche::GetQuicheCommandLineFlag(FLAGS_qbone_close_ephemeral_frames)) {
ResetStream(frame.stream_id, QUIC_STREAM_CANCELLED);
}
return;
diff --git a/quiche/quic/qbone/qbone_stream.cc b/quiche/quic/qbone/qbone_stream.cc
index 3ee8634..6465d59 100644
--- a/quiche/quic/qbone/qbone_stream.cc
+++ b/quiche/quic/qbone/qbone_stream.cc
@@ -22,8 +22,8 @@
: QuicStream(id, session, /*is_static=*/false, WRITE_UNIDIRECTIONAL) {
// QBONE uses a LIFO queue to try to always make progress. An individual
// packet may persist for upto to qbone_stream_ttl_secs seconds in memory.
- MaybeSetTtl(
- QuicTime::Delta::FromSeconds(GetQuicFlag(FLAGS_qbone_stream_ttl_secs)));
+ MaybeSetTtl(QuicTime::Delta::FromSeconds(
+ quiche::GetQuicheCommandLineFlag(FLAGS_qbone_stream_ttl_secs)));
}
void QboneWriteOnlyStream::WritePacketToQuicStream(absl::string_view packet) {
@@ -39,8 +39,8 @@
session_(session) {
// QBONE uses a LIFO queue to try to always make progress. An individual
// packet may persist for upto to qbone_stream_ttl_secs seconds in memory.
- MaybeSetTtl(
- QuicTime::Delta::FromSeconds(GetQuicFlag(FLAGS_qbone_stream_ttl_secs)));
+ MaybeSetTtl(QuicTime::Delta::FromSeconds(
+ quiche::GetQuicheCommandLineFlag(FLAGS_qbone_stream_ttl_secs)));
}
void QboneReadOnlyStream::OnDataAvailable() {
diff --git a/quiche/quic/tools/quic_client_interop_test_bin.cc b/quiche/quic/tools/quic_client_interop_test_bin.cc
index 549be2e..9a29afe 100644
--- a/quiche/quic/tools/quic_client_interop_test_bin.cc
+++ b/quiche/quic/tools/quic_client_interop_test_bin.cc
@@ -395,9 +395,9 @@
quiche::QuichePrintCommandLineFlagHelp(usage);
exit(1);
}
- std::string dns_host = GetQuicFlag(FLAGS_host);
+ std::string dns_host = quiche::GetQuicheCommandLineFlag(FLAGS_host);
std::string url_host = "";
- int port = GetQuicFlag(FLAGS_port);
+ int port = quiche::GetQuicheCommandLineFlag(FLAGS_port);
if (!args.empty()) {
quic::QuicUrl url(args[0], "https");
@@ -423,7 +423,8 @@
// Pick QUIC version to use.
quic::QuicVersionInitializeSupportForIetfDraft();
quic::ParsedQuicVersion version = quic::UnsupportedQuicVersion();
- std::string quic_version_string = GetQuicFlag(FLAGS_quic_version);
+ std::string quic_version_string =
+ quiche::GetQuicheCommandLineFlag(FLAGS_quic_version);
if (!quic_version_string.empty()) {
version = quic::ParseQuicVersionString(quic_version_string);
} else {
diff --git a/quiche/quic/tools/quic_packet_printer_bin.cc b/quiche/quic/tools/quic_packet_printer_bin.cc
index 8867e44..740971c 100644
--- a/quiche/quic/tools/quic_packet_printer_bin.cc
+++ b/quiche/quic/tools/quic_packet_printer_bin.cc
@@ -271,8 +271,8 @@
quic::QuicTime start(quic::QuicTime::Zero());
quic::QuicFramer framer(versions, start, perspective,
quic::kQuicDefaultConnectionIdLength);
- const quic::ParsedQuicVersion& version =
- quic::ParseQuicVersionString(GetQuicFlag(FLAGS_quic_version));
+ const quic::ParsedQuicVersion& version = quic::ParseQuicVersionString(
+ quiche::GetQuicheCommandLineFlag(FLAGS_quic_version));
if (version != quic::ParsedQuicVersion::Unsupported()) {
framer.set_version(version);
}
diff --git a/quiche/quic/tools/quic_toy_client.cc b/quiche/quic/tools/quic_toy_client.cc
index 9baccbf..790e263 100644
--- a/quiche/quic/tools/quic_toy_client.cc
+++ b/quiche/quic/tools/quic_toy_client.cc
@@ -230,18 +230,18 @@
int QuicToyClient::SendRequestsAndPrintResponses(
std::vector<std::string> urls) {
QuicUrl url(urls[0], "https");
- std::string host = GetQuicFlag(FLAGS_host);
+ std::string host = quiche::GetQuicheCommandLineFlag(FLAGS_host);
if (host.empty()) {
host = url.host();
}
- int port = GetQuicFlag(FLAGS_port);
+ int port = quiche::GetQuicheCommandLineFlag(FLAGS_port);
if (port == 0) {
port = url.port();
}
quic::ParsedQuicVersionVector versions = quic::CurrentSupportedVersions();
- if (GetQuicFlag(FLAGS_quic_ietf_draft)) {
+ if (quiche::GetQuicheCommandLineFlag(FLAGS_quic_ietf_draft)) {
quic::QuicVersionInitializeSupportForIetfDraft();
versions = {};
for (const ParsedQuicVersion& version : AllSupportedVersions()) {
@@ -252,7 +252,8 @@
}
}
- std::string quic_version_string = GetQuicFlag(FLAGS_quic_version);
+ std::string quic_version_string =
+ quiche::GetQuicheCommandLineFlag(FLAGS_quic_version);
if (!quic_version_string.empty()) {
versions = quic::ParseQuicVersionVectorString(quic_version_string);
}
@@ -266,36 +267,40 @@
quic::QuicEnableVersion(version);
}
- if (GetQuicFlag(FLAGS_force_version_negotiation)) {
+ if (quiche::GetQuicheCommandLineFlag(FLAGS_force_version_negotiation)) {
versions.insert(versions.begin(),
quic::QuicVersionReservedForNegotiation());
}
- const int32_t num_requests(GetQuicFlag(FLAGS_num_requests));
+ const int32_t num_requests(
+ quiche::GetQuicheCommandLineFlag(FLAGS_num_requests));
std::unique_ptr<quic::ProofVerifier> proof_verifier;
- if (GetQuicFlag(FLAGS_disable_certificate_verification)) {
+ if (quiche::GetQuicheCommandLineFlag(
+ FLAGS_disable_certificate_verification)) {
proof_verifier = std::make_unique<FakeProofVerifier>();
} else {
proof_verifier = quic::CreateDefaultProofVerifier(url.host());
}
std::unique_ptr<quic::SessionCache> session_cache;
- if (num_requests > 1 && GetQuicFlag(FLAGS_one_connection_per_request)) {
+ if (num_requests > 1 &&
+ quiche::GetQuicheCommandLineFlag(FLAGS_one_connection_per_request)) {
session_cache = std::make_unique<QuicClientSessionCache>();
}
QuicConfig config;
- std::string connection_options_string = GetQuicFlag(FLAGS_connection_options);
+ std::string connection_options_string =
+ quiche::GetQuicheCommandLineFlag(FLAGS_connection_options);
if (!connection_options_string.empty()) {
config.SetConnectionOptionsToSend(
ParseQuicTagVector(connection_options_string));
}
std::string client_connection_options_string =
- GetQuicFlag(FLAGS_client_connection_options);
+ quiche::GetQuicheCommandLineFlag(FLAGS_client_connection_options);
if (!client_connection_options_string.empty()) {
config.SetClientConnectionOptions(
ParseQuicTagVector(client_connection_options_string));
}
- if (GetQuicFlag(FLAGS_multi_packet_chlo)) {
+ if (quiche::GetQuicheCommandLineFlag(FLAGS_multi_packet_chlo)) {
// Make the ClientHello span multiple packets by adding a custom transport
// parameter.
constexpr auto kCustomParameter =
@@ -304,13 +309,16 @@
config.custom_transport_parameters_to_send()[kCustomParameter] =
custom_value;
}
- config.set_max_time_before_crypto_handshake(QuicTime::Delta::FromMilliseconds(
- GetQuicFlag(FLAGS_max_time_before_crypto_handshake_ms)));
+ config.set_max_time_before_crypto_handshake(
+ QuicTime::Delta::FromMilliseconds(quiche::GetQuicheCommandLineFlag(
+ FLAGS_max_time_before_crypto_handshake_ms)));
int address_family_for_lookup = AF_UNSPEC;
- if (GetQuicFlag(FLAGS_ip_version_for_host_lookup) == "4") {
+ if (quiche::GetQuicheCommandLineFlag(FLAGS_ip_version_for_host_lookup) ==
+ "4") {
address_family_for_lookup = AF_INET;
- } else if (GetQuicFlag(FLAGS_ip_version_for_host_lookup) == "6") {
+ } else if (quiche::GetQuicheCommandLineFlag(
+ FLAGS_ip_version_for_host_lookup) == "6") {
address_family_for_lookup = AF_INET6;
}
@@ -324,11 +332,13 @@
return 1;
}
- if (!GetQuicFlag(FLAGS_default_client_cert).empty() &&
- !GetQuicFlag(FLAGS_default_client_cert_key).empty()) {
+ if (!quiche::GetQuicheCommandLineFlag(FLAGS_default_client_cert).empty() &&
+ !quiche::GetQuicheCommandLineFlag(FLAGS_default_client_cert_key)
+ .empty()) {
std::unique_ptr<ClientProofSource> proof_source =
- CreateTestClientProofSource(GetQuicFlag(FLAGS_default_client_cert),
- GetQuicFlag(FLAGS_default_client_cert_key));
+ CreateTestClientProofSource(
+ quiche::GetQuicheCommandLineFlag(FLAGS_default_client_cert),
+ quiche::GetQuicheCommandLineFlag(FLAGS_default_client_cert_key));
if (proof_source == nullptr) {
std::cerr << "Failed to create client proof source." << std::endl;
return 1;
@@ -336,22 +346,23 @@
client->crypto_config()->set_proof_source(std::move(proof_source));
}
- int32_t initial_mtu = GetQuicFlag(FLAGS_initial_mtu);
+ int32_t initial_mtu = quiche::GetQuicheCommandLineFlag(FLAGS_initial_mtu);
client->set_initial_max_packet_length(
initial_mtu != 0 ? initial_mtu : quic::kDefaultMaxPacketSize);
- client->set_drop_response_body(GetQuicFlag(FLAGS_drop_response_body));
+ client->set_drop_response_body(
+ quiche::GetQuicheCommandLineFlag(FLAGS_drop_response_body));
const int32_t server_connection_id_length =
- GetQuicFlag(FLAGS_server_connection_id_length);
+ quiche::GetQuicheCommandLineFlag(FLAGS_server_connection_id_length);
if (server_connection_id_length >= 0) {
client->set_server_connection_id_length(server_connection_id_length);
}
const int32_t client_connection_id_length =
- GetQuicFlag(FLAGS_client_connection_id_length);
+ quiche::GetQuicheCommandLineFlag(FLAGS_client_connection_id_length);
if (client_connection_id_length >= 0) {
client->set_client_connection_id_length(client_connection_id_length);
}
const size_t max_inbound_header_list_size =
- GetQuicFlag(FLAGS_max_inbound_header_list_size);
+ quiche::GetQuicheCommandLineFlag(FLAGS_max_inbound_header_list_size);
if (max_inbound_header_list_size > 0) {
client->set_max_inbound_header_list_size(max_inbound_header_list_size);
}
@@ -366,7 +377,8 @@
<< ". " << client->session()->error_details() << std::endl;
// 0: No error.
// 20: Failed to connect due to QUIC_INVALID_VERSION.
- return GetQuicFlag(FLAGS_version_mismatch_ok) ? 0 : 20;
+ return quiche::GetQuicheCommandLineFlag(FLAGS_version_mismatch_ok) ? 0
+ : 20;
}
std::cerr << "Failed to connect to " << host << ":" << port << ". "
<< quic::QuicErrorCodeToString(error) << " "
@@ -376,11 +388,12 @@
std::cerr << "Connected to " << host << ":" << port << std::endl;
// Construct the string body from flags, if provided.
- std::string body = GetQuicFlag(FLAGS_body);
- if (!GetQuicFlag(FLAGS_body_hex).empty()) {
- QUICHE_DCHECK(GetQuicFlag(FLAGS_body).empty())
+ std::string body = quiche::GetQuicheCommandLineFlag(FLAGS_body);
+ if (!quiche::GetQuicheCommandLineFlag(FLAGS_body_hex).empty()) {
+ QUICHE_DCHECK(quiche::GetQuicheCommandLineFlag(FLAGS_body).empty())
<< "Only set one of --body and --body_hex.";
- body = absl::HexStringToBytes(GetQuicFlag(FLAGS_body_hex));
+ body = absl::HexStringToBytes(
+ quiche::GetQuicheCommandLineFlag(FLAGS_body_hex));
}
// Construct a GET or POST request for supplied URL.
@@ -391,7 +404,7 @@
header_block[":path"] = url.PathParamsQuery();
// Append any additional headers supplied on the command line.
- const std::string headers = GetQuicFlag(FLAGS_headers);
+ const std::string headers = quiche::GetQuicheCommandLineFlag(FLAGS_headers);
for (absl::string_view sp : absl::StrSplit(headers, ';')) {
QuicheTextUtils::RemoveLeadingAndTrailingWhitespace(&sp);
if (sp.empty()) {
@@ -412,14 +425,14 @@
client->SendRequestAndWaitForResponse(header_block, body, /*fin=*/true);
// Print request and response details.
- if (!GetQuicFlag(FLAGS_quiet)) {
+ if (!quiche::GetQuicheCommandLineFlag(FLAGS_quiet)) {
std::cout << "Request:" << std::endl;
std::cout << "headers:" << header_block.DebugString();
- if (!GetQuicFlag(FLAGS_body_hex).empty()) {
+ if (!quiche::GetQuicheCommandLineFlag(FLAGS_body_hex).empty()) {
// Print the user provided hex, rather than binary body.
std::cout << "body:\n"
- << QuicheTextUtils::HexDump(
- absl::HexStringToBytes(GetQuicFlag(FLAGS_body_hex)))
+ << QuicheTextUtils::HexDump(absl::HexStringToBytes(
+ quiche::GetQuicheCommandLineFlag(FLAGS_body_hex)))
<< std::endl;
} else {
std::cout << "body: " << body << std::endl;
@@ -436,7 +449,7 @@
std::cout << "headers: " << client->latest_response_headers()
<< std::endl;
std::string response_body = client->latest_response_body();
- if (!GetQuicFlag(FLAGS_body_hex).empty()) {
+ if (!quiche::GetQuicheCommandLineFlag(FLAGS_body_hex).empty()) {
// Assume response is binary data.
std::cout << "body:\n"
<< QuicheTextUtils::HexDump(response_body) << std::endl;
@@ -458,7 +471,7 @@
if (response_code >= 200 && response_code < 300) {
std::cout << "Request succeeded (" << response_code << ")." << std::endl;
} else if (response_code >= 300 && response_code < 400) {
- if (GetQuicFlag(FLAGS_redirect_is_success)) {
+ if (quiche::GetQuicheCommandLineFlag(FLAGS_redirect_is_success)) {
std::cout << "Request succeeded (redirect " << response_code << ")."
<< std::endl;
} else {
@@ -472,7 +485,7 @@
}
if (i + 1 < num_requests) { // There are more requests to perform.
- if (GetQuicFlag(FLAGS_one_connection_per_request)) {
+ if (quiche::GetQuicheCommandLineFlag(FLAGS_one_connection_per_request)) {
std::cout << "Disconnecting client between requests." << std::endl;
client->Disconnect();
if (!client->Initialize()) {
@@ -485,7 +498,8 @@
<< std::endl;
return 1;
}
- } else if (!GetQuicFlag(FLAGS_disable_port_changes)) {
+ } else if (!quiche::GetQuicheCommandLineFlag(
+ FLAGS_disable_port_changes)) {
// Change the ephemeral port.
if (!client->ChangeEphemeralPort()) {
std::cerr << "Failed to change ephemeral port." << std::endl;
diff --git a/quiche/quic/tools/quic_toy_server.cc b/quiche/quic/tools/quic_toy_server.cc
index 03f910c..1e31b2e 100644
--- a/quiche/quic/tools/quic_toy_server.cc
+++ b/quiche/quic/tools/quic_toy_server.cc
@@ -45,14 +45,15 @@
std::unique_ptr<quic::QuicSimpleServerBackend>
QuicToyServer::MemoryCacheBackendFactory::CreateBackend() {
auto memory_cache_backend = std::make_unique<QuicMemoryCacheBackend>();
- if (GetQuicFlag(FLAGS_generate_dynamic_responses)) {
+ if (quiche::GetQuicheCommandLineFlag(FLAGS_generate_dynamic_responses)) {
memory_cache_backend->GenerateDynamicResponses();
}
- if (!GetQuicFlag(FLAGS_quic_response_cache_dir).empty()) {
+ if (!quiche::GetQuicheCommandLineFlag(FLAGS_quic_response_cache_dir)
+ .empty()) {
memory_cache_backend->InitializeBackend(
- GetQuicFlag(FLAGS_quic_response_cache_dir));
+ quiche::GetQuicheCommandLineFlag(FLAGS_quic_response_cache_dir));
}
- if (GetQuicFlag(FLAGS_enable_webtransport)) {
+ if (quiche::GetQuicheCommandLineFlag(FLAGS_enable_webtransport)) {
memory_cache_backend->EnableWebTransport();
}
return memory_cache_backend;
@@ -64,7 +65,7 @@
int QuicToyServer::Start() {
ParsedQuicVersionVector supported_versions;
- if (GetQuicFlag(FLAGS_quic_ietf_draft)) {
+ if (quiche::GetQuicheCommandLineFlag(FLAGS_quic_ietf_draft)) {
QuicVersionInitializeSupportForIetfDraft();
for (const ParsedQuicVersion& version : AllSupportedVersions()) {
// Add all versions that supports IETF QUIC.
@@ -76,7 +77,8 @@
} else {
supported_versions = AllSupportedVersions();
}
- std::string versions_string = GetQuicFlag(FLAGS_quic_versions);
+ std::string versions_string =
+ quiche::GetQuicheCommandLineFlag(FLAGS_quic_versions);
if (!versions_string.empty()) {
supported_versions = ParseQuicVersionVectorString(versions_string);
}
@@ -92,7 +94,8 @@
backend.get(), std::move(proof_source), supported_versions);
if (!server->CreateUDPSocketAndListen(quic::QuicSocketAddress(
- quic::QuicIpAddress::Any6(), GetQuicFlag(FLAGS_port)))) {
+ quic::QuicIpAddress::Any6(),
+ quiche::GetQuicheCommandLineFlag(FLAGS_port)))) {
return 1;
}
