1 // Copyright (c) 2009 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 #include <vector> 12 13 #include "base/linked_ptr.h" 14 #include "base/ref_counted.h" 15 #include "base/scoped_ptr.h" 16 #include "base/task.h" 17 #include "net/base/address_list.h" 18 #include "net/base/completion_callback.h" 19 #include "net/base/io_buffer.h" 20 #include "net/http/http_auth.h" 21 #include "net/http/http_auth_cache.h" 22 #include "net/http/http_auth_handler.h" 23 #include "net/proxy/proxy_service.h" 24 #include "net/socket/tcp_client_socket.h" 25 #include "net/url_request/request_tracker.h" 26 #include "net/url_request/url_request_context.h" 27 28 namespace net { 29 30 class AuthChallengeInfo; 31 class ClientSocketFactory; 32 class HostResolver; 33 class LoadLog; 34 class SSLConfigService; 35 class SingleRequestHostResolver; 36 class SocketStreamMetrics; 37 class SocketStreamThrottle; 38 39 // SocketStream is used to implement Web Sockets. 40 // It provides plain full-duplex stream with proxy and SSL support. 41 // For proxy authentication, only basic mechanisum is supported. It will try 42 // authentication identity for proxy URL first. If server requires proxy 43 // authentication, it will try authentication identity for realm that server 44 // requests. 45 class SocketStream : public base::RefCountedThreadSafe<SocketStream> { 46 public: 47 // Derive from this class and add your own data members to associate extra 48 // information with a SocketStream. Use GetUserData(key) and 49 // SetUserData(key, data). 50 class UserData { 51 public: 52 UserData() {} 53 virtual ~UserData() {} 54 }; 55 56 class Delegate { 57 public: 58 virtual ~Delegate() {} 59 60 // Called when socket stream has been connected. The socket stream accepts 61 // at most |max_pending_send_allowed| so that a client of the socket stream 62 // should keep track of how much it has pending and shouldn't go over 63 // |max_pending_send_allowed| bytes. 64 virtual void OnConnected(SocketStream* socket, 65 int max_pending_send_allowed) = 0; 66 67 // Called when |amount_sent| bytes of data are sent. 68 virtual void OnSentData(SocketStream* socket, 69 int amount_sent) = 0; 70 71 // Called when |len| bytes of |data| are received. 72 virtual void OnReceivedData(SocketStream* socket, 73 const char* data, int len) = 0; 74 75 // Called when the socket stream has been closed. 76 virtual void OnClose(SocketStream* socket) = 0; 77 78 // Called when proxy authentication required. 79 // The delegate should call RestartWithAuth() if credential for |auth_info| 80 // is found in password database, or call Close() to close the connection. 81 virtual void OnAuthRequired(SocketStream* socket, 82 AuthChallengeInfo* auth_info) { 83 // By default, no credential is available and close the connection. 84 socket->Close(); 85 } 86 87 // Called when an error occured. 88 // This is only for error reporting to the delegate. 89 // |error| is net::Error. 90 virtual void OnError(const SocketStream* socket, int error) {} 91 }; 92 93 SocketStream(const GURL& url, Delegate* delegate); 94 95 // The user data allows the clients to associate data with this job. 96 // Multiple user data values can be stored under different keys. 97 // This job will TAKE OWNERSHIP of the given data pointer, and will 98 // delete the object if it is changed or the job is destroyed. 99 UserData* GetUserData(const void* key) const; 100 void SetUserData(const void* key, UserData* data); 101 102 const GURL& url() const { return url_; } 103 const AddressList& address_list() const { return addresses_; } 104 Delegate* delegate() const { return delegate_; } 105 int max_pending_send_allowed() const { return max_pending_send_allowed_; } 106 107 URLRequestContext* context() const { return context_.get(); } 108 void set_context(URLRequestContext* context); 109 110 LoadLog* load_log() const { return load_log_; } 111 112 // Opens the connection on the IO thread. 113 // Once the connection is established, calls delegate's OnConnected. 114 void Connect(); 115 116 // Requests to send |len| bytes of |data| on the connection. 117 // Returns true if |data| is buffered in the job. 118 // Returns false if size of buffered data would exceeds 119 // |max_pending_send_allowed_| and |data| is not sent at all. 120 bool SendData(const char* data, int len); 121 122 // Requests to close the connection. 123 // Once the connection is closed, calls delegate's OnClose. 124 void Close(); 125 126 // Restarts with authentication info. 127 // Should be used for response of OnAuthRequired. 128 void RestartWithAuth( 129 const std::wstring& username, 130 const std::wstring& password); 131 132 // Detach delegate. Call before delegate is deleted. 133 // Once delegate is detached, close the socket stream and never call delegate 134 // back. 135 void DetachDelegate(); 136 137 // Sets an alternative HostResolver. For testing purposes only. 138 void SetHostResolver(HostResolver* host_resolver); 139 140 // Sets an alternative ClientSocketFactory. Doesn't take ownership of 141 // |factory|. For testing purposes only. 142 void SetClientSocketFactory(ClientSocketFactory* factory); 143 144 private: 145 class RequestHeaders : public IOBuffer { 146 public: 147 RequestHeaders() : IOBuffer() {} 148 149 void SetDataOffset(size_t offset) { 150 data_ = const_cast<char*>(headers_.data()) + offset; 151 } 152 153 std::string headers_; 154 155 private: 156 ~RequestHeaders() { data_ = NULL; } 157 }; 158 159 class ResponseHeaders : public IOBuffer { 160 public: 161 ResponseHeaders() : IOBuffer() {} 162 163 void SetDataOffset(size_t offset) { data_ = headers_.get() + offset; } 164 char* headers() const { return headers_.get(); } 165 void Reset() { headers_.reset(); } 166 void Realloc(size_t new_size); 167 168 private: 169 ~ResponseHeaders() { data_ = NULL; } 170 171 scoped_ptr_malloc<char> headers_; 172 }; 173 174 enum State { 175 STATE_NONE, 176 STATE_RESOLVE_PROXY, 177 STATE_RESOLVE_PROXY_COMPLETE, 178 STATE_RESOLVE_HOST, 179 STATE_RESOLVE_HOST_COMPLETE, 180 STATE_TCP_CONNECT, 181 STATE_TCP_CONNECT_COMPLETE, 182 STATE_WRITE_TUNNEL_HEADERS, 183 STATE_WRITE_TUNNEL_HEADERS_COMPLETE, 184 STATE_READ_TUNNEL_HEADERS, 185 STATE_READ_TUNNEL_HEADERS_COMPLETE, 186 STATE_SOCKS_CONNECT, 187 STATE_SOCKS_CONNECT_COMPLETE, 188 STATE_SSL_CONNECT, 189 STATE_SSL_CONNECT_COMPLETE, 190 STATE_READ_WRITE, 191 STATE_AUTH_REQUIRED, 192 STATE_CLOSE, 193 }; 194 195 enum ProxyMode { 196 kDirectConnection, // If using a direct connection 197 kTunnelProxy, // If using a tunnel (CONNECT method as HTTPS) 198 kSOCKSProxy, // If using a SOCKS proxy 199 }; 200 201 typedef std::deque< scoped_refptr<IOBufferWithSize> > PendingDataQueue; 202 friend class RequestTracker<SocketStream>; 203 friend class base::RefCountedThreadSafe<SocketStream>; 204 ~SocketStream(); 205 206 friend class WebSocketThrottleTest; 207 208 // Copies the given addrinfo list in |addresses_|. 209 // Used for WebSocketThrottleTest. 210 void CopyAddrInfo(struct addrinfo* head); 211 212 // Finishes the job. 213 // Calls OnError and OnClose of delegate, and no more 214 // notifications will be sent to delegate. 215 void Finish(int result); 216 217 int DidEstablishConnection(); 218 int DidReceiveData(int result); 219 int DidSendData(int result); 220 221 void OnIOCompleted(int result); 222 void OnReadCompleted(int result); 223 void OnWriteCompleted(int result); 224 225 void DoLoop(int result); 226 227 int DoResolveProxy(); 228 int DoResolveProxyComplete(int result); 229 int DoResolveHost(); 230 int DoResolveHostComplete(int result); 231 int DoTcpConnect(); 232 int DoTcpConnectComplete(int result); 233 int DoWriteTunnelHeaders(); 234 int DoWriteTunnelHeadersComplete(int result); 235 int DoReadTunnelHeaders(); 236 int DoReadTunnelHeadersComplete(int result); 237 int DoSOCKSConnect(); 238 int DoSOCKSConnectComplete(int result); 239 int DoSSLConnect(); 240 int DoSSLConnectComplete(int result); 241 int DoReadWrite(int result); 242 243 GURL ProxyAuthOrigin() const; 244 int HandleAuthChallenge(const HttpResponseHeaders* headers); 245 void DoAuthRequired(); 246 void DoRestartWithAuth(); 247 248 int HandleCertificateError(int result); 249 250 bool is_secure() const; 251 SSLConfigService* ssl_config_service() const; 252 ProxyService* proxy_service() const; 253 254 void GetInfoForTracker( 255 RequestTracker<SocketStream>::RecentRequestInfo* info) const; 256 257 scoped_refptr<LoadLog> load_log_; 258 259 GURL url_; 260 Delegate* delegate_; 261 int max_pending_send_allowed_; 262 scoped_refptr<URLRequestContext> context_; 263 264 typedef std::map<const void*, linked_ptr<UserData> > UserDataMap; 265 UserDataMap user_data_; 266 267 State next_state_; 268 scoped_refptr<HostResolver> host_resolver_; 269 ClientSocketFactory* factory_; 270 271 ProxyMode proxy_mode_; 272 273 GURL proxy_url_; 274 ProxyService::PacRequest* pac_request_; 275 ProxyInfo proxy_info_; 276 277 HttpAuthCache auth_cache_; 278 scoped_refptr<HttpAuthHandler> auth_handler_; 279 HttpAuth::Identity auth_identity_; 280 scoped_refptr<AuthChallengeInfo> auth_info_; 281 282 scoped_refptr<RequestHeaders> tunnel_request_headers_; 283 size_t tunnel_request_headers_bytes_sent_; 284 scoped_refptr<ResponseHeaders> tunnel_response_headers_; 285 int tunnel_response_headers_capacity_; 286 int tunnel_response_headers_len_; 287 288 // Use the same number as HttpNetworkTransaction::kMaxHeaderBufSize. 289 enum { kMaxTunnelResponseHeadersSize = 32768 }; // 32 kilobytes. 290 291 scoped_ptr<SingleRequestHostResolver> resolver_; 292 AddressList addresses_; 293 scoped_ptr<ClientSocket> socket_; 294 295 SSLConfig ssl_config_; 296 297 CompletionCallbackImpl<SocketStream> io_callback_; 298 CompletionCallbackImpl<SocketStream> read_callback_; 299 CompletionCallbackImpl<SocketStream> write_callback_; 300 301 scoped_refptr<IOBuffer> read_buf_; 302 int read_buf_size_; 303 304 // Total amount of buffer (|write_buf_size_| - |write_buf_offset_| + 305 // sum of size of |pending_write_bufs_|) should not exceed 306 // |max_pending_send_allowed_|. 307 // |write_buf_| holds requested data and |current_write_buf_| is used 308 // for Write operation, that is, |current_write_buf_| is 309 // |write_buf_| + |write_buf_offset_|. 310 scoped_refptr<IOBuffer> write_buf_; 311 scoped_refptr<DrainableIOBuffer> current_write_buf_; 312 int write_buf_offset_; 313 int write_buf_size_; 314 PendingDataQueue pending_write_bufs_; 315 316 SocketStreamThrottle* throttle_; 317 318 scoped_ptr<SocketStreamMetrics> metrics_; 319 320 RequestTracker<SocketStream>::Node request_tracker_node_; 321 322 DISALLOW_COPY_AND_ASSIGN(SocketStream); 323 }; 324 325 } // namespace net 326 327 #endif // NET_SOCKET_STREAM_SOCKET_STREAM_H_ 328