websocket_test_util.cc 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294
  1. // Copyright 2013 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/websockets/websocket_test_util.h"
  5. #include <stddef.h>
  6. #include <algorithm>
  7. #include <utility>
  8. #include "base/strings/strcat.h"
  9. #include "base/strings/string_util.h"
  10. #include "base/strings/stringprintf.h"
  11. #include "net/base/ip_endpoint.h"
  12. #include "net/http/http_network_session.h"
  13. #include "net/proxy_resolution/configured_proxy_resolution_service.h"
  14. #include "net/socket/socket_test_util.h"
  15. #include "net/third_party/quiche/src/quiche/spdy/core/spdy_protocol.h"
  16. #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
  17. #include "net/url_request/url_request_context.h"
  18. #include "net/url_request/url_request_context_builder.h"
  19. #include "net/websockets/websocket_basic_handshake_stream.h"
  20. #include "url/origin.h"
  21. namespace net {
  22. namespace {
  23. const uint64_t kA = (static_cast<uint64_t>(0x5851f42d) << 32) +
  24. static_cast<uint64_t>(0x4c957f2d);
  25. const uint64_t kC = 12345;
  26. const uint64_t kM = static_cast<uint64_t>(1) << 48;
  27. } // namespace
  28. LinearCongruentialGenerator::LinearCongruentialGenerator(uint32_t seed)
  29. : current_(seed) {}
  30. uint32_t LinearCongruentialGenerator::Generate() {
  31. uint64_t result = current_;
  32. current_ = (current_ * kA + kC) % kM;
  33. return static_cast<uint32_t>(result >> 16);
  34. }
  35. std::string WebSocketExtraHeadersToString(
  36. const WebSocketExtraHeaders& headers) {
  37. std::string answer;
  38. for (const auto& header : headers) {
  39. base::StrAppend(&answer, {header.first, ": ", header.second, "\r\n"});
  40. }
  41. return answer;
  42. }
  43. HttpRequestHeaders WebSocketExtraHeadersToHttpRequestHeaders(
  44. const WebSocketExtraHeaders& headers) {
  45. HttpRequestHeaders headers_to_return;
  46. for (const auto& header : headers)
  47. headers_to_return.SetHeader(header.first, header.second);
  48. return headers_to_return;
  49. }
  50. std::string WebSocketStandardRequest(
  51. const std::string& path,
  52. const std::string& host,
  53. const url::Origin& origin,
  54. const WebSocketExtraHeaders& send_additional_request_headers,
  55. const WebSocketExtraHeaders& extra_headers) {
  56. return WebSocketStandardRequestWithCookies(path, host, origin, /*cookies=*/{},
  57. send_additional_request_headers,
  58. extra_headers);
  59. }
  60. std::string WebSocketStandardRequestWithCookies(
  61. const std::string& path,
  62. const std::string& host,
  63. const url::Origin& origin,
  64. const WebSocketExtraHeaders& cookies,
  65. const WebSocketExtraHeaders& send_additional_request_headers,
  66. const WebSocketExtraHeaders& extra_headers) {
  67. // Unrelated changes in net/http may change the order and default-values of
  68. // HTTP headers, causing WebSocket tests to fail. It is safe to update this
  69. // in that case.
  70. HttpRequestHeaders headers;
  71. std::stringstream request_headers;
  72. request_headers << base::StringPrintf("GET %s HTTP/1.1\r\n", path.c_str());
  73. headers.SetHeader("Host", host);
  74. headers.SetHeader("Connection", "Upgrade");
  75. headers.SetHeader("Pragma", "no-cache");
  76. headers.SetHeader("Cache-Control", "no-cache");
  77. for (const auto& [key, value] : send_additional_request_headers)
  78. headers.SetHeader(key, value);
  79. headers.SetHeader("Upgrade", "websocket");
  80. headers.SetHeader("Origin", origin.Serialize());
  81. headers.SetHeader("Sec-WebSocket-Version", "13");
  82. if (!headers.HasHeader("User-Agent"))
  83. headers.SetHeader("User-Agent", "");
  84. headers.SetHeader("Accept-Encoding", "gzip, deflate");
  85. headers.SetHeader("Accept-Language", "en-us,fr");
  86. for (const auto& [key, value] : cookies)
  87. headers.SetHeader(key, value);
  88. headers.SetHeader("Sec-WebSocket-Key", "dGhlIHNhbXBsZSBub25jZQ==");
  89. headers.SetHeader("Sec-WebSocket-Extensions",
  90. "permessage-deflate; client_max_window_bits");
  91. for (const auto& [key, value] : extra_headers)
  92. headers.SetHeader(key, value);
  93. request_headers << headers.ToString();
  94. return request_headers.str();
  95. }
  96. std::string WebSocketStandardResponse(const std::string& extra_headers) {
  97. return base::StringPrintf(
  98. "HTTP/1.1 101 Switching Protocols\r\n"
  99. "Upgrade: websocket\r\n"
  100. "Connection: Upgrade\r\n"
  101. "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
  102. "%s\r\n",
  103. extra_headers.c_str());
  104. }
  105. HttpRequestHeaders WebSocketCommonTestHeaders() {
  106. HttpRequestHeaders request_headers;
  107. request_headers.SetHeader("Host", "www.example.org");
  108. request_headers.SetHeader("Connection", "Upgrade");
  109. request_headers.SetHeader("Pragma", "no-cache");
  110. request_headers.SetHeader("Cache-Control", "no-cache");
  111. request_headers.SetHeader("Upgrade", "websocket");
  112. request_headers.SetHeader("Origin", "http://origin.example.org");
  113. request_headers.SetHeader("Sec-WebSocket-Version", "13");
  114. request_headers.SetHeader("User-Agent", "");
  115. request_headers.SetHeader("Accept-Encoding", "gzip, deflate");
  116. request_headers.SetHeader("Accept-Language", "en-us,fr");
  117. return request_headers;
  118. }
  119. spdy::Http2HeaderBlock WebSocketHttp2Request(
  120. const std::string& path,
  121. const std::string& authority,
  122. const std::string& origin,
  123. const WebSocketExtraHeaders& extra_headers) {
  124. spdy::Http2HeaderBlock request_headers;
  125. request_headers[spdy::kHttp2MethodHeader] = "CONNECT";
  126. request_headers[spdy::kHttp2AuthorityHeader] = authority;
  127. request_headers[spdy::kHttp2SchemeHeader] = "https";
  128. request_headers[spdy::kHttp2PathHeader] = path;
  129. request_headers[spdy::kHttp2ProtocolHeader] = "websocket";
  130. request_headers["pragma"] = "no-cache";
  131. request_headers["cache-control"] = "no-cache";
  132. request_headers["origin"] = origin;
  133. request_headers["sec-websocket-version"] = "13";
  134. request_headers["user-agent"] = "";
  135. request_headers["accept-encoding"] = "gzip, deflate";
  136. request_headers["accept-language"] = "en-us,fr";
  137. request_headers["sec-websocket-extensions"] =
  138. "permessage-deflate; client_max_window_bits";
  139. for (const auto& header : extra_headers) {
  140. request_headers[base::ToLowerASCII(header.first)] = header.second;
  141. }
  142. return request_headers;
  143. }
  144. spdy::Http2HeaderBlock WebSocketHttp2Response(
  145. const WebSocketExtraHeaders& extra_headers) {
  146. spdy::Http2HeaderBlock response_headers;
  147. response_headers[spdy::kHttp2StatusHeader] = "200";
  148. for (const auto& header : extra_headers) {
  149. response_headers[base::ToLowerASCII(header.first)] = header.second;
  150. }
  151. return response_headers;
  152. }
  153. struct WebSocketMockClientSocketFactoryMaker::Detail {
  154. std::string expect_written;
  155. std::string return_to_read;
  156. std::vector<MockRead> reads;
  157. MockWrite write;
  158. std::vector<std::unique_ptr<SequencedSocketData>> socket_data_vector;
  159. std::vector<std::unique_ptr<SSLSocketDataProvider>> ssl_socket_data_vector;
  160. MockClientSocketFactory factory;
  161. };
  162. WebSocketMockClientSocketFactoryMaker::WebSocketMockClientSocketFactoryMaker()
  163. : detail_(std::make_unique<Detail>()) {}
  164. WebSocketMockClientSocketFactoryMaker::
  165. ~WebSocketMockClientSocketFactoryMaker() = default;
  166. MockClientSocketFactory* WebSocketMockClientSocketFactoryMaker::factory() {
  167. return &detail_->factory;
  168. }
  169. void WebSocketMockClientSocketFactoryMaker::SetExpectations(
  170. const std::string& expect_written,
  171. const std::string& return_to_read) {
  172. const size_t kHttpStreamParserBufferSize = 4096;
  173. // We need to extend the lifetime of these strings.
  174. detail_->expect_written = expect_written;
  175. detail_->return_to_read = return_to_read;
  176. int sequence = 0;
  177. detail_->write = MockWrite(SYNCHRONOUS,
  178. detail_->expect_written.data(),
  179. detail_->expect_written.size(),
  180. sequence++);
  181. // HttpStreamParser reads 4KB at a time. We need to take this implementation
  182. // detail into account if |return_to_read| is big enough.
  183. for (size_t place = 0; place < detail_->return_to_read.size();
  184. place += kHttpStreamParserBufferSize) {
  185. detail_->reads.emplace_back(SYNCHRONOUS,
  186. detail_->return_to_read.data() + place,
  187. std::min(detail_->return_to_read.size() - place,
  188. kHttpStreamParserBufferSize),
  189. sequence++);
  190. }
  191. auto socket_data = std::make_unique<SequencedSocketData>(
  192. detail_->reads, base::make_span(&detail_->write, 1));
  193. socket_data->set_connect_data(MockConnect(SYNCHRONOUS, OK));
  194. AddRawExpectations(std::move(socket_data));
  195. }
  196. void WebSocketMockClientSocketFactoryMaker::AddRawExpectations(
  197. std::unique_ptr<SequencedSocketData> socket_data) {
  198. detail_->factory.AddSocketDataProvider(socket_data.get());
  199. detail_->socket_data_vector.push_back(std::move(socket_data));
  200. }
  201. void WebSocketMockClientSocketFactoryMaker::AddSSLSocketDataProvider(
  202. std::unique_ptr<SSLSocketDataProvider> ssl_socket_data) {
  203. detail_->factory.AddSSLSocketDataProvider(ssl_socket_data.get());
  204. detail_->ssl_socket_data_vector.push_back(std::move(ssl_socket_data));
  205. }
  206. WebSocketTestURLRequestContextHost::WebSocketTestURLRequestContextHost()
  207. : url_request_context_builder_(CreateTestURLRequestContextBuilder()) {
  208. url_request_context_builder_->set_client_socket_factory_for_testing(
  209. maker_.factory());
  210. HttpNetworkSessionParams params;
  211. params.enable_spdy_ping_based_connection_checking = false;
  212. params.enable_quic = false;
  213. params.disable_idle_sockets_close_on_memory_pressure = false;
  214. url_request_context_builder_->set_http_network_session_params(params);
  215. }
  216. WebSocketTestURLRequestContextHost::~WebSocketTestURLRequestContextHost() =
  217. default;
  218. void WebSocketTestURLRequestContextHost::AddRawExpectations(
  219. std::unique_ptr<SequencedSocketData> socket_data) {
  220. maker_.AddRawExpectations(std::move(socket_data));
  221. }
  222. void WebSocketTestURLRequestContextHost::AddSSLSocketDataProvider(
  223. std::unique_ptr<SSLSocketDataProvider> ssl_socket_data) {
  224. maker_.AddSSLSocketDataProvider(std::move(ssl_socket_data));
  225. }
  226. void WebSocketTestURLRequestContextHost::SetProxyConfig(
  227. const std::string& proxy_rules) {
  228. DCHECK(!url_request_context_);
  229. auto proxy_resolution_service =
  230. ConfiguredProxyResolutionService::CreateFixedForTest(
  231. proxy_rules, TRAFFIC_ANNOTATION_FOR_TESTS);
  232. url_request_context_builder_->set_proxy_resolution_service(
  233. std::move(proxy_resolution_service));
  234. }
  235. int DummyConnectDelegate::OnAuthRequired(
  236. const AuthChallengeInfo& auth_info,
  237. scoped_refptr<HttpResponseHeaders> response_headers,
  238. const IPEndPoint& host_port_pair,
  239. base::OnceCallback<void(const AuthCredentials*)> callback,
  240. absl::optional<AuthCredentials>* credentials) {
  241. return OK;
  242. }
  243. URLRequestContext* WebSocketTestURLRequestContextHost::GetURLRequestContext() {
  244. if (!url_request_context_) {
  245. url_request_context_builder_->set_network_delegate(
  246. std::make_unique<TestNetworkDelegate>());
  247. url_request_context_ = url_request_context_builder_->Build();
  248. url_request_context_builder_ = nullptr;
  249. }
  250. return url_request_context_.get();
  251. }
  252. void TestWebSocketStreamRequestAPI::OnBasicHandshakeStreamCreated(
  253. WebSocketBasicHandshakeStream* handshake_stream) {
  254. handshake_stream->SetWebSocketKeyForTesting("dGhlIHNhbXBsZSBub25jZQ==");
  255. }
  256. void TestWebSocketStreamRequestAPI::OnHttp2HandshakeStreamCreated(
  257. WebSocketHttp2HandshakeStream* handshake_stream) {}
  258. } // namespace net