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 5 #ifndef NET_WEBSOCKETS_WEBSOCKET_BASIC_HANDSHAKE_STREAM_H_ 6 #define NET_WEBSOCKETS_WEBSOCKET_BASIC_HANDSHAKE_STREAM_H_ 7 8 #include <string> 9 #include <vector> 10 11 #include "base/memory/ref_counted.h" 12 #include "base/memory/scoped_ptr.h" 13 #include "net/base/net_export.h" 14 #include "net/http/http_basic_state.h" 15 #include "net/websockets/websocket_handshake_stream_base.h" 16 #include "url/gurl.h" 17 18 namespace net { 19 20 class ClientSocketHandle; 21 class HttpResponseHeaders; 22 class HttpResponseInfo; 23 class HttpStreamParser; 24 25 struct WebSocketExtensionParams; 26 27 class NET_EXPORT_PRIVATE WebSocketBasicHandshakeStream 28 : public WebSocketHandshakeStreamBase { 29 public: 30 // |connect_delegate| and |failure_message| must out-live this object. 31 WebSocketBasicHandshakeStream( 32 scoped_ptr<ClientSocketHandle> connection, 33 WebSocketStream::ConnectDelegate* connect_delegate, 34 bool using_proxy, 35 std::vector<std::string> requested_sub_protocols, 36 std::vector<std::string> requested_extensions, 37 std::string* failure_message); 38 39 virtual ~WebSocketBasicHandshakeStream(); 40 41 // HttpStreamBase methods 42 virtual int InitializeStream(const HttpRequestInfo* request_info, 43 RequestPriority priority, 44 const BoundNetLog& net_log, 45 const CompletionCallback& callback) OVERRIDE; 46 virtual int SendRequest(const HttpRequestHeaders& request_headers, 47 HttpResponseInfo* response, 48 const CompletionCallback& callback) OVERRIDE; 49 virtual int ReadResponseHeaders(const CompletionCallback& callback) OVERRIDE; 50 virtual int ReadResponseBody(IOBuffer* buf, 51 int buf_len, 52 const CompletionCallback& callback) OVERRIDE; 53 virtual void Close(bool not_reusable) OVERRIDE; 54 virtual bool IsResponseBodyComplete() const OVERRIDE; 55 virtual bool CanFindEndOfResponse() const OVERRIDE; 56 virtual bool IsConnectionReused() const OVERRIDE; 57 virtual void SetConnectionReused() OVERRIDE; 58 virtual bool IsConnectionReusable() const OVERRIDE; 59 virtual int64 GetTotalReceivedBytes() const OVERRIDE; 60 virtual bool GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const 61 OVERRIDE; 62 virtual void GetSSLInfo(SSLInfo* ssl_info) OVERRIDE; 63 virtual void GetSSLCertRequestInfo( 64 SSLCertRequestInfo* cert_request_info) OVERRIDE; 65 virtual bool IsSpdyHttpStream() const OVERRIDE; 66 virtual void Drain(HttpNetworkSession* session) OVERRIDE; 67 virtual void SetPriority(RequestPriority priority) OVERRIDE; 68 69 // This is called from the top level once correct handshake response headers 70 // have been received. It creates an appropriate subclass of WebSocketStream 71 // depending on what extensions were negotiated. This object is unusable after 72 // Upgrade() has been called and should be disposed of as soon as possible. 73 virtual scoped_ptr<WebSocketStream> Upgrade() OVERRIDE; 74 75 // Set the value used for the next Sec-WebSocket-Key header 76 // deterministically. The key is only used once, and then discarded. 77 // For tests only. 78 void SetWebSocketKeyForTesting(const std::string& key); 79 80 private: 81 // A wrapper for the ReadResponseHeaders callback that checks whether or not 82 // the connection has been accepted. 83 void ReadResponseHeadersCallback(const CompletionCallback& callback, 84 int result); 85 86 void OnFinishOpeningHandshake(); 87 88 // Validates the response and sends the finished handshake event. 89 int ValidateResponse(int rv); 90 91 // Check that the headers are well-formed for a 101 response, and returns 92 // OK if they are, otherwise returns ERR_INVALID_RESPONSE. 93 int ValidateUpgradeResponse(const HttpResponseHeaders* headers); 94 parser()95 HttpStreamParser* parser() const { return state_.parser(); } 96 97 void set_failure_message(const std::string& failure_message); 98 99 // The request URL. 100 GURL url_; 101 102 // HttpBasicState holds most of the handshake-related state. 103 HttpBasicState state_; 104 105 // Owned by another object. 106 // |connect_delegate| will live during the lifetime of this object. 107 WebSocketStream::ConnectDelegate* connect_delegate_; 108 109 // This is stored in SendRequest() for use by ReadResponseHeaders(). 110 HttpResponseInfo* http_response_info_; 111 112 // The key to be sent in the next Sec-WebSocket-Key header. Usually NULL (the 113 // key is generated on the fly). 114 scoped_ptr<std::string> handshake_challenge_for_testing_; 115 116 // The required value for the Sec-WebSocket-Accept header. 117 std::string handshake_challenge_response_; 118 119 // The sub-protocols we requested. 120 std::vector<std::string> requested_sub_protocols_; 121 122 // The extensions we requested. 123 std::vector<std::string> requested_extensions_; 124 125 // The sub-protocol selected by the server. 126 std::string sub_protocol_; 127 128 // The extension(s) selected by the server. 129 std::string extensions_; 130 131 // The extension parameters. The class is defined in the implementation file 132 // to avoid including extension-related header files here. 133 scoped_ptr<WebSocketExtensionParams> extension_params_; 134 135 std::string* failure_message_; 136 137 DISALLOW_COPY_AND_ASSIGN(WebSocketBasicHandshakeStream); 138 }; 139 140 } // namespace net 141 142 #endif // NET_WEBSOCKETS_WEBSOCKET_BASIC_HANDSHAKE_STREAM_H_ 143