1 // Copyright (c) 2019 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "quiche/quic/qbone/qbone_client.h"
6
7 #include <utility>
8
9
10 #include "absl/strings/string_view.h"
11 #include "quiche/quic/core/io/quic_event_loop.h"
12 #include "quiche/quic/core/quic_bandwidth.h"
13 #include "quiche/quic/core/quic_default_connection_helper.h"
14 #include "quiche/quic/platform/api/quic_testvalue.h"
15 #include "quiche/quic/tools/quic_client_default_network_helper.h"
16
17 namespace quic {
18 namespace {
CreateNetworkHelper(QuicEventLoop * event_loop,QboneClient * client)19 std::unique_ptr<QuicClientBase::NetworkHelper> CreateNetworkHelper(
20 QuicEventLoop* event_loop, QboneClient* client) {
21 std::unique_ptr<QuicClientBase::NetworkHelper> helper =
22 std::make_unique<QuicClientDefaultNetworkHelper>(event_loop, client);
23 quic::AdjustTestValue("QboneClient/network_helper", &helper);
24 return helper;
25 }
26 } // namespace
27
QboneClient(QuicSocketAddress server_address,const QuicServerId & server_id,const ParsedQuicVersionVector & supported_versions,QuicSession::Visitor * session_owner,const QuicConfig & config,QuicEventLoop * event_loop,std::unique_ptr<ProofVerifier> proof_verifier,QbonePacketWriter * qbone_writer,QboneClientControlStream::Handler * qbone_handler)28 QboneClient::QboneClient(QuicSocketAddress server_address,
29 const QuicServerId& server_id,
30 const ParsedQuicVersionVector& supported_versions,
31 QuicSession::Visitor* session_owner,
32 const QuicConfig& config, QuicEventLoop* event_loop,
33 std::unique_ptr<ProofVerifier> proof_verifier,
34 QbonePacketWriter* qbone_writer,
35 QboneClientControlStream::Handler* qbone_handler)
36 : QuicClientBase(server_id, supported_versions, config,
37 new QuicDefaultConnectionHelper(),
38 event_loop->CreateAlarmFactory().release(),
39 CreateNetworkHelper(event_loop, this),
40 std::move(proof_verifier), nullptr),
41 qbone_writer_(qbone_writer),
42 qbone_handler_(qbone_handler),
43 session_owner_(session_owner),
44 max_pacing_rate_(QuicBandwidth::Zero()) {
45 set_server_address(server_address);
46 crypto_config()->set_alpn("qbone");
47 }
48
~QboneClient()49 QboneClient::~QboneClient() { ResetSession(); }
50
qbone_session()51 QboneClientSession* QboneClient::qbone_session() {
52 return static_cast<QboneClientSession*>(QuicClientBase::session());
53 }
54
ProcessPacketFromNetwork(absl::string_view packet)55 void QboneClient::ProcessPacketFromNetwork(absl::string_view packet) {
56 qbone_session()->ProcessPacketFromNetwork(packet);
57 }
58
EarlyDataAccepted()59 bool QboneClient::EarlyDataAccepted() {
60 return qbone_session()->EarlyDataAccepted();
61 }
62
ReceivedInchoateReject()63 bool QboneClient::ReceivedInchoateReject() {
64 return qbone_session()->ReceivedInchoateReject();
65 }
66
GetNumSentClientHellosFromSession()67 int QboneClient::GetNumSentClientHellosFromSession() {
68 return qbone_session()->GetNumSentClientHellos();
69 }
70
GetNumReceivedServerConfigUpdatesFromSession()71 int QboneClient::GetNumReceivedServerConfigUpdatesFromSession() {
72 return qbone_session()->GetNumReceivedServerConfigUpdates();
73 }
74
ResendSavedData()75 void QboneClient::ResendSavedData() {
76 // no op.
77 }
78
ClearDataToResend()79 void QboneClient::ClearDataToResend() {
80 // no op.
81 }
82
HasActiveRequests()83 bool QboneClient::HasActiveRequests() {
84 return qbone_session()->HasActiveRequests();
85 }
86
87 class QboneClientSessionWithConnection : public QboneClientSession {
88 public:
89 using QboneClientSession::QboneClientSession;
90
~QboneClientSessionWithConnection()91 ~QboneClientSessionWithConnection() override { DeleteConnection(); }
92 };
93
94 // Takes ownership of |connection|.
CreateQuicClientSession(const ParsedQuicVersionVector & supported_versions,QuicConnection * connection)95 std::unique_ptr<QuicSession> QboneClient::CreateQuicClientSession(
96 const ParsedQuicVersionVector& supported_versions,
97 QuicConnection* connection) {
98 if (max_pacing_rate() > quic::QuicBandwidth::Zero()) {
99 QUIC_LOG(INFO) << "Setting max pacing rate to " << max_pacing_rate();
100 connection->SetMaxPacingRate(max_pacing_rate());
101 }
102 return std::make_unique<QboneClientSessionWithConnection>(
103 connection, crypto_config(), session_owner(), *config(),
104 supported_versions, server_id(), qbone_writer_, qbone_handler_);
105 }
106
use_quarantine_mode() const107 bool QboneClient::use_quarantine_mode() const { return use_quarantine_mode_; }
set_use_quarantine_mode(bool use_quarantine_mode)108 void QboneClient::set_use_quarantine_mode(bool use_quarantine_mode) {
109 use_quarantine_mode_ = use_quarantine_mode;
110 }
111 } // namespace quic
112