1 // Copyright 2015 The Chromium Authors
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 "net/quic/quic_stream_factory_peer.h"
6
7 #include <string>
8 #include <vector>
9
10 #include "base/task/sequenced_task_runner.h"
11 #include "net/cert/x509_certificate.h"
12 #include "net/cert/x509_util.h"
13 #include "net/dns/public/secure_dns_policy.h"
14 #include "net/quic/platform/impl/quic_chromium_clock.h"
15 #include "net/quic/quic_chromium_client_session.h"
16 #include "net/quic/quic_http_stream.h"
17 #include "net/quic/quic_stream_factory.h"
18 #include "net/test/cert_test_util.h"
19 #include "net/test/test_data_directory.h"
20 #include "net/third_party/quiche/src/quiche/quic/core/crypto/quic_crypto_client_config.h"
21 #include "url/scheme_host_port.h"
22
23 using std::string;
24
25 namespace net::test {
26
GetConfig(QuicStreamFactory * factory)27 const quic::QuicConfig* QuicStreamFactoryPeer::GetConfig(
28 QuicStreamFactory* factory) {
29 return &factory->config_;
30 }
31
32 std::unique_ptr<QuicCryptoClientConfigHandle>
GetCryptoConfig(QuicStreamFactory * factory,const NetworkAnonymizationKey & network_anonymization_key)33 QuicStreamFactoryPeer::GetCryptoConfig(
34 QuicStreamFactory* factory,
35 const NetworkAnonymizationKey& network_anonymization_key) {
36 return factory->GetCryptoConfigForTesting(network_anonymization_key);
37 }
38
HasActiveSession(QuicStreamFactory * factory,const quic::QuicServerId & server_id,const NetworkAnonymizationKey & network_anonymization_key,bool require_dns_https_alpn)39 bool QuicStreamFactoryPeer::HasActiveSession(
40 QuicStreamFactory* factory,
41 const quic::QuicServerId& server_id,
42 const NetworkAnonymizationKey& network_anonymization_key,
43 bool require_dns_https_alpn) {
44 return factory->HasActiveSession(
45 QuicSessionKey(server_id, SocketTag(), network_anonymization_key,
46 SecureDnsPolicy::kAllow, require_dns_https_alpn));
47 }
48
HasActiveJob(QuicStreamFactory * factory,const quic::QuicServerId & server_id,bool require_dns_https_alpn)49 bool QuicStreamFactoryPeer::HasActiveJob(QuicStreamFactory* factory,
50 const quic::QuicServerId& server_id,
51 bool require_dns_https_alpn) {
52 return factory->HasActiveJob(
53 QuicSessionKey(server_id, SocketTag(), NetworkAnonymizationKey(),
54 SecureDnsPolicy::kAllow, require_dns_https_alpn));
55 }
56
57 // static
GetPendingSession(QuicStreamFactory * factory,const quic::QuicServerId & server_id,url::SchemeHostPort destination)58 QuicChromiumClientSession* QuicStreamFactoryPeer::GetPendingSession(
59 QuicStreamFactory* factory,
60 const quic::QuicServerId& server_id,
61 url::SchemeHostPort destination) {
62 QuicSessionKey session_key(server_id, SocketTag(), NetworkAnonymizationKey(),
63 SecureDnsPolicy::kAllow,
64 /*require_dns_https_alpn=*/false);
65 QuicStreamFactory::QuicSessionAliasKey key(std::move(destination),
66 session_key);
67 DCHECK(factory->HasActiveJob(session_key));
68 DCHECK_EQ(factory->all_sessions_.size(), 1u);
69 DCHECK(key == factory->all_sessions_.begin()->second);
70 return factory->all_sessions_.begin()->first;
71 }
72
GetActiveSession(QuicStreamFactory * factory,const quic::QuicServerId & server_id,const NetworkAnonymizationKey & network_anonymization_key,bool require_dns_https_alpn)73 QuicChromiumClientSession* QuicStreamFactoryPeer::GetActiveSession(
74 QuicStreamFactory* factory,
75 const quic::QuicServerId& server_id,
76 const NetworkAnonymizationKey& network_anonymization_key,
77 bool require_dns_https_alpn) {
78 QuicSessionKey session_key(server_id, SocketTag(), network_anonymization_key,
79 SecureDnsPolicy::kAllow, require_dns_https_alpn);
80 DCHECK(factory->HasActiveSession(session_key));
81 return factory->active_sessions_[session_key];
82 }
83
HasLiveSession(QuicStreamFactory * factory,url::SchemeHostPort destination,const quic::QuicServerId & server_id,bool require_dns_https_alpn)84 bool QuicStreamFactoryPeer::HasLiveSession(QuicStreamFactory* factory,
85 url::SchemeHostPort destination,
86 const quic::QuicServerId& server_id,
87 bool require_dns_https_alpn) {
88 QuicSessionKey session_key =
89 QuicSessionKey(server_id, SocketTag(), NetworkAnonymizationKey(),
90 SecureDnsPolicy::kAllow, require_dns_https_alpn);
91 QuicStreamFactory::QuicSessionAliasKey alias_key(std::move(destination),
92 session_key);
93 for (const auto& it : factory->all_sessions_) {
94 if (it.second == alias_key)
95 return true;
96 }
97 return false;
98 }
99
IsLiveSession(QuicStreamFactory * factory,QuicChromiumClientSession * session)100 bool QuicStreamFactoryPeer::IsLiveSession(QuicStreamFactory* factory,
101 QuicChromiumClientSession* session) {
102 for (const auto& it : factory->all_sessions_) {
103 if (it.first == session)
104 return true;
105 }
106 return false;
107 }
108
SetTaskRunner(QuicStreamFactory * factory,base::SequencedTaskRunner * task_runner)109 void QuicStreamFactoryPeer::SetTaskRunner(
110 QuicStreamFactory* factory,
111 base::SequencedTaskRunner* task_runner) {
112 factory->task_runner_ = task_runner;
113 }
114
SetTickClock(QuicStreamFactory * factory,const base::TickClock * tick_clock)115 void QuicStreamFactoryPeer::SetTickClock(QuicStreamFactory* factory,
116 const base::TickClock* tick_clock) {
117 factory->tick_clock_ = tick_clock;
118 }
119
GetPingTimeout(QuicStreamFactory * factory)120 quic::QuicTime::Delta QuicStreamFactoryPeer::GetPingTimeout(
121 QuicStreamFactory* factory) {
122 return factory->ping_timeout_;
123 }
124
SetYieldAfterPackets(QuicStreamFactory * factory,int yield_after_packets)125 void QuicStreamFactoryPeer::SetYieldAfterPackets(QuicStreamFactory* factory,
126 int yield_after_packets) {
127 factory->yield_after_packets_ = yield_after_packets;
128 }
129
SetYieldAfterDuration(QuicStreamFactory * factory,quic::QuicTime::Delta yield_after_duration)130 void QuicStreamFactoryPeer::SetYieldAfterDuration(
131 QuicStreamFactory* factory,
132 quic::QuicTime::Delta yield_after_duration) {
133 factory->yield_after_duration_ = yield_after_duration;
134 }
135
CryptoConfigCacheIsEmpty(QuicStreamFactory * factory,const quic::QuicServerId & quic_server_id,const NetworkAnonymizationKey & network_anonymization_key)136 bool QuicStreamFactoryPeer::CryptoConfigCacheIsEmpty(
137 QuicStreamFactory* factory,
138 const quic::QuicServerId& quic_server_id,
139 const NetworkAnonymizationKey& network_anonymization_key) {
140 return factory->CryptoConfigCacheIsEmptyForTesting(quic_server_id,
141 network_anonymization_key);
142 }
143
CacheDummyServerConfig(QuicStreamFactory * factory,const quic::QuicServerId & quic_server_id,const NetworkAnonymizationKey & network_anonymization_key)144 void QuicStreamFactoryPeer::CacheDummyServerConfig(
145 QuicStreamFactory* factory,
146 const quic::QuicServerId& quic_server_id,
147 const NetworkAnonymizationKey& network_anonymization_key) {
148 // Minimum SCFG that passes config validation checks.
149 const char scfg[] = {// SCFG
150 0x53, 0x43, 0x46, 0x47,
151 // num entries
152 0x01, 0x00,
153 // padding
154 0x00, 0x00,
155 // EXPY
156 0x45, 0x58, 0x50, 0x59,
157 // EXPY end offset
158 0x08, 0x00, 0x00, 0x00,
159 // Value
160 '1', '2', '3', '4', '5', '6', '7', '8'};
161
162 string server_config(reinterpret_cast<const char*>(&scfg), sizeof(scfg));
163 string source_address_token("test_source_address_token");
164 string signature("test_signature");
165
166 std::vector<string> certs;
167 // Load a certificate that is valid for *.example.org
168 scoped_refptr<X509Certificate> cert(
169 ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem"));
170 DCHECK(cert);
171 certs.emplace_back(x509_util::CryptoBufferAsStringPiece(cert->cert_buffer()));
172
173 std::unique_ptr<QuicCryptoClientConfigHandle> crypto_config_handle =
174 GetCryptoConfig(factory, network_anonymization_key);
175 quic::QuicCryptoClientConfig::CachedState* cached =
176 crypto_config_handle->GetConfig()->LookupOrCreate(quic_server_id);
177 quic::QuicChromiumClock clock;
178 cached->Initialize(server_config, source_address_token, certs, "", "",
179 signature, clock.WallNow(), quic::QuicWallTime::Zero());
180 DCHECK(!cached->certs().empty());
181 }
182
GetNumPushStreamsCreated(QuicStreamFactory * factory)183 int QuicStreamFactoryPeer::GetNumPushStreamsCreated(
184 QuicStreamFactory* factory) {
185 return factory->num_push_streams_created_;
186 }
187
GetNumDegradingSessions(QuicStreamFactory * factory)188 size_t QuicStreamFactoryPeer::GetNumDegradingSessions(
189 QuicStreamFactory* factory) {
190 return factory->connectivity_monitor_.GetNumDegradingSessions();
191 }
192
SetAlarmFactory(QuicStreamFactory * factory,std::unique_ptr<quic::QuicAlarmFactory> alarm_factory)193 void QuicStreamFactoryPeer::SetAlarmFactory(
194 QuicStreamFactory* factory,
195 std::unique_ptr<quic::QuicAlarmFactory> alarm_factory) {
196 factory->alarm_factory_ = std::move(alarm_factory);
197 }
198
199 } // namespace net::test
200