1 // Copyright (c) 2012 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_SOCKET_STREAM_SOCKET_STREAM_H_ 6 #define NET_SOCKET_STREAM_SOCKET_STREAM_H_ 7 8 #include <deque> 9 #include <map> 10 #include <string> 11 12 #include "base/memory/linked_ptr.h" 13 #include "base/memory/ref_counted.h" 14 #include "base/memory/scoped_ptr.h" 15 #include "net/base/address_list.h" 16 #include "net/base/completion_callback.h" 17 #include "net/base/io_buffer.h" 18 #include "net/base/net_errors.h" 19 #include "net/base/net_export.h" 20 #include "net/base/net_log.h" 21 #include "net/base/privacy_mode.h" 22 #include "net/cookies/cookie_store.h" 23 #include "net/proxy/proxy_service.h" 24 #include "net/ssl/ssl_config_service.h" 25 #include "net/url_request/url_request.h" 26 27 namespace net { 28 29 class AuthChallengeInfo; 30 class CertVerifier; 31 class ChannelIDService; 32 class ClientSocketFactory; 33 class ClientSocketHandle; 34 class CookieOptions; 35 class HostResolver; 36 class HttpAuthController; 37 class SSLInfo; 38 class SingleRequestHostResolver; 39 class SocketStreamMetrics; 40 class TransportSecurityState; 41 class URLRequestContext; 42 43 // SocketStream is used to implement Web Sockets. 44 // It provides plain full-duplex stream with proxy and SSL support. 45 // For proxy authentication, only basic mechanisum is supported. It will try 46 // authentication identity for proxy URL first. If server requires proxy 47 // authentication, it will try authentication identity for realm that server 48 // requests. 49 class NET_EXPORT SocketStream 50 : public base::RefCountedThreadSafe<SocketStream> { 51 public: 52 // Derive from this class and add your own data members to associate extra 53 // information with a SocketStream. Use GetUserData(key) and 54 // SetUserData(key, data). 55 class UserData { 56 public: 57 UserData() {} 58 virtual ~UserData() {} 59 }; 60 61 class NET_EXPORT Delegate { 62 public: 63 virtual int OnStartOpenConnection(SocketStream* socket, 64 const CompletionCallback& callback); 65 66 // Called when a socket stream has been connected. The socket stream is 67 // allowed to buffer pending send data at most |max_pending_send_allowed| 68 // bytes. A client of the socket stream should keep track of how much 69 // pending send data it has and must not call SendData() if the pending 70 // data goes over |max_pending_send_allowed| bytes. 71 virtual void OnConnected(SocketStream* socket, 72 int max_pending_send_allowed) = 0; 73 74 // Called when |amount_sent| bytes of data are sent. 75 virtual void OnSentData(SocketStream* socket, 76 int amount_sent) = 0; 77 78 // Called when |len| bytes of |data| are received. 79 virtual void OnReceivedData(SocketStream* socket, 80 const char* data, int len) = 0; 81 82 // Called when the socket stream has been closed. 83 virtual void OnClose(SocketStream* socket) = 0; 84 85 // Called when proxy authentication required. 86 // The delegate should call RestartWithAuth() if credential for |auth_info| 87 // is found in password database, or call Close() to close the connection. 88 virtual void OnAuthRequired(SocketStream* socket, 89 AuthChallengeInfo* auth_info); 90 91 // Called when using SSL and the server responds with a certificate with an 92 // error. The delegate should call CancelBecauseOfCertError() or 93 // ContinueDespiteCertError() to resume connection handling. 94 virtual void OnSSLCertificateError(SocketStream* socket, 95 const SSLInfo& ssl_info, 96 bool fatal); 97 98 // Called when an error occured. 99 // This is only for error reporting to the delegate. 100 // |error| is net::Error. 101 virtual void OnError(const SocketStream* socket, int error) {} 102 103 // Called when reading cookies to allow the delegate to block access to the 104 // cookie. 105 virtual bool CanGetCookies(SocketStream* socket, const GURL& url); 106 107 // Called when a cookie is set to allow the delegate to block access to the 108 // cookie. 109 virtual bool CanSetCookie(SocketStream* request, 110 const GURL& url, 111 const std::string& cookie_line, 112 CookieOptions* options); 113 114 protected: 115 virtual ~Delegate() {} 116 }; 117 118 SocketStream(const GURL& url, Delegate* delegate, URLRequestContext* context, 119 CookieStore* cookie_store); 120 121 // The user data allows the clients to associate data with this job. 122 // Multiple user data values can be stored under different keys. 123 // This job will TAKE OWNERSHIP of the given data pointer, and will 124 // delete the object if it is changed or the job is destroyed. 125 UserData* GetUserData(const void* key) const; 126 void SetUserData(const void* key, UserData* data); 127 128 const GURL& url() const { return url_; } 129 bool is_secure() const; 130 const AddressList& address_list() const { return addresses_; } 131 Delegate* delegate() const { return delegate_; } 132 int max_pending_send_allowed() const { return max_pending_send_allowed_; } 133 134 URLRequestContext* context() { return context_; } 135 136 const SSLConfig& server_ssl_config() const { return server_ssl_config_; } 137 PrivacyMode privacy_mode() const { return privacy_mode_; } 138 void CheckPrivacyMode(); 139 140 BoundNetLog* net_log() { return &net_log_; } 141 142 // Opens the connection on the IO thread. 143 // Once the connection is established, calls delegate's OnConnected. 144 virtual void Connect(); 145 146 // Buffers |data| of |len| bytes for send and returns true if successful. 147 // If size of buffered data exceeds |max_pending_send_allowed_|, sends no 148 // data and returns false. |len| must be positive. 149 virtual bool SendData(const char* data, int len); 150 151 // Requests to close the connection. 152 // Once the connection is closed, calls delegate's OnClose. 153 virtual void Close(); 154 155 // Restarts with authentication info. 156 // Should be used for response of OnAuthRequired. 157 virtual void RestartWithAuth(const AuthCredentials& credentials); 158 159 // Detach delegate. Call before delegate is deleted. 160 // Once delegate is detached, close the socket stream and never call delegate 161 // back. 162 virtual void DetachDelegate(); 163 164 // Detach the context. 165 virtual void DetachContext(); 166 167 const ProxyServer& proxy_server() const; 168 169 // Sets an alternative ClientSocketFactory. Doesn't take ownership of 170 // |factory|. For testing purposes only. 171 void SetClientSocketFactory(ClientSocketFactory* factory); 172 173 // Cancels the connection because of an error. 174 // |error| is net::Error which represents the error. 175 void CancelWithError(int error); 176 177 // Cancels the connection because of receiving a certificate with an error. 178 void CancelWithSSLError(const SSLInfo& ssl_info); 179 180 // Continues to establish the connection in spite of an error. Usually this 181 // case happens because users allow certificate with an error by manual 182 // actions on alert dialog or browser cached such kinds of user actions. 183 void ContinueDespiteError(); 184 185 CookieStore* cookie_store() const; 186 187 protected: 188 friend class base::RefCountedThreadSafe<SocketStream>; 189 virtual ~SocketStream(); 190 191 Delegate* delegate_; 192 193 private: 194 FRIEND_TEST_ALL_PREFIXES(SocketStreamTest, IOPending); 195 FRIEND_TEST_ALL_PREFIXES(SocketStreamTest, SwitchAfterPending); 196 FRIEND_TEST_ALL_PREFIXES(SocketStreamTest, 197 NullContextSocketStreamShouldNotCrash); 198 199 friend class WebSocketThrottleTest; 200 201 typedef std::map<const void*, linked_ptr<UserData> > UserDataMap; 202 typedef std::deque< scoped_refptr<IOBufferWithSize> > PendingDataQueue; 203 204 class RequestHeaders : public IOBuffer { 205 public: 206 RequestHeaders() : IOBuffer() {} 207 208 void SetDataOffset(size_t offset) { 209 data_ = const_cast<char*>(headers_.data()) + offset; 210 } 211 212 std::string headers_; 213 214 private: 215 virtual ~RequestHeaders(); 216 }; 217 218 class ResponseHeaders : public IOBuffer { 219 public: 220 ResponseHeaders(); 221 222 void SetDataOffset(size_t offset) { data_ = headers_.get() + offset; } 223 char* headers() const { return headers_.get(); } 224 void Reset() { headers_.reset(); } 225 void Realloc(size_t new_size); 226 227 private: 228 virtual ~ResponseHeaders(); 229 230 scoped_ptr<char, base::FreeDeleter> headers_; 231 }; 232 233 enum State { 234 STATE_NONE, 235 STATE_BEFORE_CONNECT, 236 STATE_BEFORE_CONNECT_COMPLETE, 237 STATE_RESOLVE_PROXY, 238 STATE_RESOLVE_PROXY_COMPLETE, 239 STATE_RESOLVE_HOST, 240 STATE_RESOLVE_HOST_COMPLETE, 241 STATE_RESOLVE_PROTOCOL, 242 STATE_RESOLVE_PROTOCOL_COMPLETE, 243 STATE_TCP_CONNECT, 244 STATE_TCP_CONNECT_COMPLETE, 245 STATE_GENERATE_PROXY_AUTH_TOKEN, 246 STATE_GENERATE_PROXY_AUTH_TOKEN_COMPLETE, 247 STATE_WRITE_TUNNEL_HEADERS, 248 STATE_WRITE_TUNNEL_HEADERS_COMPLETE, 249 STATE_READ_TUNNEL_HEADERS, 250 STATE_READ_TUNNEL_HEADERS_COMPLETE, 251 STATE_SOCKS_CONNECT, 252 STATE_SOCKS_CONNECT_COMPLETE, 253 STATE_SECURE_PROXY_CONNECT, 254 STATE_SECURE_PROXY_CONNECT_COMPLETE, 255 STATE_SECURE_PROXY_HANDLE_CERT_ERROR, 256 STATE_SECURE_PROXY_HANDLE_CERT_ERROR_COMPLETE, 257 STATE_SSL_CONNECT, 258 STATE_SSL_CONNECT_COMPLETE, 259 STATE_SSL_HANDLE_CERT_ERROR, 260 STATE_SSL_HANDLE_CERT_ERROR_COMPLETE, 261 STATE_READ_WRITE, 262 STATE_AUTH_REQUIRED, 263 STATE_CLOSE, 264 }; 265 266 enum ProxyMode { 267 kDirectConnection, // If using a direct connection 268 kTunnelProxy, // If using a tunnel (CONNECT method as HTTPS) 269 kSOCKSProxy, // If using a SOCKS proxy 270 }; 271 272 // Use the same number as HttpNetworkTransaction::kMaxHeaderBufSize. 273 enum { kMaxTunnelResponseHeadersSize = 32768 }; // 32 kilobytes. 274 275 // Used for WebSocketThrottleTest. 276 void set_addresses(const AddressList& addresses); 277 278 void DoClose(); 279 280 // Finishes the job. 281 // Calls OnError and OnClose of delegate, and no more 282 // notifications will be sent to delegate. 283 void Finish(int result); 284 285 int DidEstablishConnection(); 286 int DidReceiveData(int result); 287 // Given the number of bytes sent, 288 // - notifies the |delegate_| and |metrics_| of this event. 289 // - drains sent data from |current_write_buf_|. 290 // - if |current_write_buf_| has been fully sent, sets NULL to 291 // |current_write_buf_| to get ready for next write. 292 // and then, returns OK. 293 void DidSendData(int result); 294 295 void OnIOCompleted(int result); 296 void OnReadCompleted(int result); 297 void OnWriteCompleted(int result); 298 299 void DoLoop(int result); 300 301 int DoBeforeConnect(); 302 int DoBeforeConnectComplete(int result); 303 int DoResolveProxy(); 304 int DoResolveProxyComplete(int result); 305 int DoResolveHost(); 306 int DoResolveHostComplete(int result); 307 int DoResolveProtocol(int result); 308 int DoResolveProtocolComplete(int result); 309 int DoTcpConnect(int result); 310 int DoTcpConnectComplete(int result); 311 int DoGenerateProxyAuthToken(); 312 int DoGenerateProxyAuthTokenComplete(int result); 313 int DoWriteTunnelHeaders(); 314 int DoWriteTunnelHeadersComplete(int result); 315 int DoReadTunnelHeaders(); 316 int DoReadTunnelHeadersComplete(int result); 317 int DoSOCKSConnect(); 318 int DoSOCKSConnectComplete(int result); 319 int DoSecureProxyConnect(); 320 int DoSecureProxyConnectComplete(int result); 321 int DoSecureProxyHandleCertError(int result); 322 int DoSecureProxyHandleCertErrorComplete(int result); 323 int DoSSLConnect(); 324 int DoSSLConnectComplete(int result); 325 int DoSSLHandleCertError(int result); 326 int DoSSLHandleCertErrorComplete(int result); 327 int DoReadWrite(int result); 328 329 GURL ProxyAuthOrigin() const; 330 int HandleAuthChallenge(const HttpResponseHeaders* headers); 331 int HandleCertificateRequest(int result, SSLConfig* ssl_config); 332 void DoAuthRequired(); 333 void DoRestartWithAuth(); 334 335 int HandleCertificateError(int result); 336 int AllowCertErrorForReconnection(SSLConfig* ssl_config); 337 338 // Returns the sum of the size of buffers in |pending_write_bufs_|. 339 size_t GetTotalSizeOfPendingWriteBufs() const; 340 341 BoundNetLog net_log_; 342 343 GURL url_; 344 // The number of bytes allowed to be buffered in this object. If the size of 345 // buffered data which is 346 // current_write_buf_.BytesRemaining() + 347 // sum of the size of buffers in |pending_write_bufs_| 348 // exceeds this limit, SendData() fails. 349 int max_pending_send_allowed_; 350 URLRequestContext* context_; 351 352 UserDataMap user_data_; 353 354 State next_state_; 355 ClientSocketFactory* factory_; 356 357 ProxyMode proxy_mode_; 358 359 GURL proxy_url_; 360 ProxyService::PacRequest* pac_request_; 361 ProxyInfo proxy_info_; 362 363 scoped_refptr<HttpAuthController> proxy_auth_controller_; 364 365 scoped_refptr<RequestHeaders> tunnel_request_headers_; 366 size_t tunnel_request_headers_bytes_sent_; 367 scoped_refptr<ResponseHeaders> tunnel_response_headers_; 368 int tunnel_response_headers_capacity_; 369 int tunnel_response_headers_len_; 370 371 scoped_ptr<SingleRequestHostResolver> resolver_; 372 AddressList addresses_; 373 scoped_ptr<ClientSocketHandle> connection_; 374 375 SSLConfig server_ssl_config_; 376 SSLConfig proxy_ssl_config_; 377 PrivacyMode privacy_mode_; 378 379 CompletionCallback io_callback_; 380 381 scoped_refptr<IOBuffer> read_buf_; 382 int read_buf_size_; 383 384 // Buffer to hold data to pass to socket_. 385 scoped_refptr<DrainableIOBuffer> current_write_buf_; 386 // True iff there's no error and this instance is waiting for completion of 387 // Write operation by socket_. 388 bool waiting_for_write_completion_; 389 PendingDataQueue pending_write_bufs_; 390 391 bool closing_; 392 bool server_closed_; 393 394 scoped_ptr<SocketStreamMetrics> metrics_; 395 396 // Cookie store to use for this socket stream. 397 scoped_refptr<CookieStore> cookie_store_; 398 399 DISALLOW_COPY_AND_ASSIGN(SocketStream); 400 }; 401 402 } // namespace net 403 404 #endif // NET_SOCKET_STREAM_SOCKET_STREAM_H_ 405