quic_stream_factory_peer.cc 7.2 KB

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