websocket_http2_handshake_stream.h 7.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201
  1. // Copyright 2018 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. #ifndef NET_WEBSOCKETS_WEBSOCKET_HTTP2_HANDSHAKE_STREAM_H_
  5. #define NET_WEBSOCKETS_WEBSOCKET_HTTP2_HANDSHAKE_STREAM_H_
  6. #include <stdint.h>
  7. #include <memory>
  8. #include <set>
  9. #include <string>
  10. #include <vector>
  11. #include "base/memory/raw_ptr.h"
  12. #include "base/memory/weak_ptr.h"
  13. #include "base/strings/string_piece.h"
  14. #include "net/base/completion_once_callback.h"
  15. #include "net/base/io_buffer.h"
  16. #include "net/base/net_export.h"
  17. #include "net/base/request_priority.h"
  18. #include "net/log/net_log_with_source.h"
  19. #include "net/third_party/quiche/src/quiche/spdy/core/http2_header_block.h"
  20. #include "net/websockets/websocket_basic_stream_adapters.h"
  21. #include "net/websockets/websocket_handshake_stream_base.h"
  22. #include "net/websockets/websocket_stream.h"
  23. #include "third_party/abseil-cpp/absl/types/optional.h"
  24. namespace net {
  25. struct LoadTimingInfo;
  26. class SSLInfo;
  27. class IOBuffer;
  28. class SSLCertRequestInfo;
  29. class IPEndPoint;
  30. class HttpNetworkSession;
  31. struct NetErrorDetails;
  32. class HttpStream;
  33. class HttpResponseHeaders;
  34. struct HttpRequestInfo;
  35. class HttpResponseInfo;
  36. class SpdySession;
  37. struct AlternativeService;
  38. class SpdyStreamRequest;
  39. struct WebSocketExtensionParams;
  40. class NET_EXPORT_PRIVATE WebSocketHttp2HandshakeStream
  41. : public WebSocketHandshakeStreamBase,
  42. public WebSocketSpdyStreamAdapter::Delegate {
  43. public:
  44. // |connect_delegate| and |request| must out-live this object.
  45. WebSocketHttp2HandshakeStream(
  46. base::WeakPtr<SpdySession> session,
  47. WebSocketStream::ConnectDelegate* connect_delegate,
  48. std::vector<std::string> requested_sub_protocols,
  49. std::vector<std::string> requested_extensions,
  50. WebSocketStreamRequestAPI* request,
  51. std::set<std::string> dns_aliases);
  52. WebSocketHttp2HandshakeStream(const WebSocketHttp2HandshakeStream&) = delete;
  53. WebSocketHttp2HandshakeStream& operator=(
  54. const WebSocketHttp2HandshakeStream&) = delete;
  55. ~WebSocketHttp2HandshakeStream() override;
  56. // HttpStream methods.
  57. void RegisterRequest(const HttpRequestInfo* request_info) override;
  58. int InitializeStream(bool can_send_early,
  59. RequestPriority priority,
  60. const NetLogWithSource& net_log,
  61. CompletionOnceCallback callback) override;
  62. int SendRequest(const HttpRequestHeaders& request_headers,
  63. HttpResponseInfo* response,
  64. CompletionOnceCallback callback) override;
  65. int ReadResponseHeaders(CompletionOnceCallback callback) override;
  66. int ReadResponseBody(IOBuffer* buf,
  67. int buf_len,
  68. CompletionOnceCallback callback) override;
  69. void Close(bool not_reusable) override;
  70. bool IsResponseBodyComplete() const override;
  71. bool IsConnectionReused() const override;
  72. void SetConnectionReused() override;
  73. bool CanReuseConnection() const override;
  74. int64_t GetTotalReceivedBytes() const override;
  75. int64_t GetTotalSentBytes() const override;
  76. bool GetAlternativeService(
  77. AlternativeService* alternative_service) const override;
  78. bool GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const override;
  79. void GetSSLInfo(SSLInfo* ssl_info) override;
  80. void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info) override;
  81. int GetRemoteEndpoint(IPEndPoint* endpoint) override;
  82. void Drain(HttpNetworkSession* session) override;
  83. void SetPriority(RequestPriority priority) override;
  84. void PopulateNetErrorDetails(NetErrorDetails* details) override;
  85. std::unique_ptr<HttpStream> RenewStreamForAuth() override;
  86. const std::set<std::string>& GetDnsAliases() const override;
  87. base::StringPiece GetAcceptChViaAlps() const override;
  88. // WebSocketHandshakeStreamBase methods.
  89. // This is called from the top level once correct handshake response headers
  90. // have been received. It creates an appropriate subclass of WebSocketStream
  91. // depending on what extensions were negotiated. This object is unusable after
  92. // Upgrade() has been called and should be disposed of as soon as possible.
  93. std::unique_ptr<WebSocketStream> Upgrade() override;
  94. base::WeakPtr<WebSocketHandshakeStreamBase> GetWeakPtr() override;
  95. // WebSocketSpdyStreamAdapter::Delegate methods.
  96. void OnHeadersSent() override;
  97. void OnHeadersReceived(
  98. const spdy::Http2HeaderBlock& response_headers) override;
  99. void OnClose(int status) override;
  100. // Called by |spdy_stream_request_| when requested stream is ready.
  101. void StartRequestCallback(int rv);
  102. private:
  103. // Validates the response and sends the finished handshake event.
  104. int ValidateResponse();
  105. // Check that the headers are well-formed and have a 200 status code,
  106. // in which case returns OK, otherwise returns ERR_INVALID_RESPONSE.
  107. int ValidateUpgradeResponse(const HttpResponseHeaders* headers);
  108. void OnFailure(const std::string& message,
  109. int net_error,
  110. absl::optional<int> response_code);
  111. HandshakeResult result_ = HandshakeResult::HTTP2_INCOMPLETE;
  112. // The connection to open the Websocket stream on.
  113. base::WeakPtr<SpdySession> session_;
  114. // Owned by another object.
  115. // |connect_delegate| will live during the lifetime of this object.
  116. const raw_ptr<WebSocketStream::ConnectDelegate> connect_delegate_;
  117. raw_ptr<HttpResponseInfo> http_response_info_ = nullptr;
  118. spdy::Http2HeaderBlock http2_request_headers_;
  119. // The sub-protocols we requested.
  120. std::vector<std::string> requested_sub_protocols_;
  121. // The extensions we requested.
  122. std::vector<std::string> requested_extensions_;
  123. const raw_ptr<WebSocketStreamRequestAPI> stream_request_;
  124. raw_ptr<const HttpRequestInfo> request_info_ = nullptr;
  125. RequestPriority priority_;
  126. NetLogWithSource net_log_;
  127. // SpdyStreamRequest that will create the stream.
  128. std::unique_ptr<SpdyStreamRequest> spdy_stream_request_;
  129. // SpdyStream corresponding to the request.
  130. base::WeakPtr<SpdyStream> stream_;
  131. // WebSocketSpdyStreamAdapter holding a WeakPtr to |stream_|.
  132. // This can be passed on to WebSocketBasicStream when created.
  133. std::unique_ptr<WebSocketSpdyStreamAdapter> stream_adapter_;
  134. // True if |stream_| has been created then closed.
  135. bool stream_closed_ = false;
  136. // The error code corresponding to the reason for closing the stream.
  137. // Only meaningful if |stream_closed_| is true.
  138. int stream_error_ = OK;
  139. // True if complete response headers have been received.
  140. bool response_headers_complete_ = false;
  141. // Save callback provided in asynchronous HttpStream methods.
  142. CompletionOnceCallback callback_;
  143. // The sub-protocol selected by the server.
  144. std::string sub_protocol_;
  145. // The extension(s) selected by the server.
  146. std::string extensions_;
  147. // The extension parameters. The class is defined in the implementation file
  148. // to avoid including extension-related header files here.
  149. std::unique_ptr<WebSocketExtensionParams> extension_params_;
  150. // Stores any DNS aliases for the remote endpoint. Includes all known aliases,
  151. // e.g. from A, AAAA, or HTTPS, not just from the address used for the
  152. // connection, in no particular order. These are stored in the stream instead
  153. // of the session due to complications related to IP-pooling.
  154. std::set<std::string> dns_aliases_;
  155. base::WeakPtrFactory<WebSocketHttp2HandshakeStream> weak_ptr_factory_{this};
  156. };
  157. } // namespace net
  158. #endif // NET_WEBSOCKETS_WEBSOCKET_HTTP2_HANDSHAKE_STREAM_H_