| OLD | NEW |
|---|
| (Empty) |
| 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 ~RequestHeaders() override; | |
| 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 ~ResponseHeaders() override; | |
| 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_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 723343002:
Update from https://crrev.com/304121 (Closed)
Base URL: git@github.com:domokit/mojo.git@master