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_HTTP_HTTP_NETWORK_TRANSACTION_H_ 6 #define NET_HTTP_HTTP_NETWORK_TRANSACTION_H_ 7 8 #include <string> 9 10 #include "base/basictypes.h" 11 #include "base/gtest_prod_util.h" 12 #include "base/memory/ref_counted.h" 13 #include "base/memory/scoped_ptr.h" 14 #include "base/time/time.h" 15 #include "net/base/net_log.h" 16 #include "net/base/request_priority.h" 17 #include "net/http/http_auth.h" 18 #include "net/http/http_request_headers.h" 19 #include "net/http/http_response_info.h" 20 #include "net/http/http_stream_factory.h" 21 #include "net/http/http_transaction.h" 22 #include "net/proxy/proxy_service.h" 23 #include "net/ssl/ssl_config_service.h" 24 #include "net/websockets/websocket_handshake_stream_base.h" 25 26 namespace net { 27 28 class ClientSocketHandle; 29 class HttpAuthController; 30 class HttpNetworkSession; 31 class HttpStreamBase; 32 class HttpStreamRequest; 33 class IOBuffer; 34 class SpdySession; 35 struct HttpRequestInfo; 36 37 class NET_EXPORT_PRIVATE HttpNetworkTransaction 38 : public HttpTransaction, 39 public HttpStreamRequest::Delegate { 40 public: 41 HttpNetworkTransaction(RequestPriority priority, 42 HttpNetworkSession* session); 43 44 virtual ~HttpNetworkTransaction(); 45 46 // HttpTransaction methods: 47 virtual int Start(const HttpRequestInfo* request_info, 48 const CompletionCallback& callback, 49 const BoundNetLog& net_log) OVERRIDE; 50 virtual int RestartIgnoringLastError( 51 const CompletionCallback& callback) OVERRIDE; 52 virtual int RestartWithCertificate( 53 X509Certificate* client_cert, 54 const CompletionCallback& callback) OVERRIDE; 55 virtual int RestartWithAuth(const AuthCredentials& credentials, 56 const CompletionCallback& callback) OVERRIDE; 57 virtual bool IsReadyToRestartForAuth() OVERRIDE; 58 59 virtual int Read(IOBuffer* buf, 60 int buf_len, 61 const CompletionCallback& callback) OVERRIDE; 62 virtual void StopCaching() OVERRIDE; 63 virtual bool GetFullRequestHeaders( 64 HttpRequestHeaders* headers) const OVERRIDE; 65 virtual int64 GetTotalReceivedBytes() const OVERRIDE; 66 virtual void DoneReading() OVERRIDE; 67 virtual const HttpResponseInfo* GetResponseInfo() const OVERRIDE; 68 virtual LoadState GetLoadState() const OVERRIDE; 69 virtual UploadProgress GetUploadProgress() const OVERRIDE; 70 virtual void SetQuicServerInfo(QuicServerInfo* quic_server_info) OVERRIDE; 71 virtual bool GetLoadTimingInfo( 72 LoadTimingInfo* load_timing_info) const OVERRIDE; 73 virtual void SetPriority(RequestPriority priority) OVERRIDE; 74 virtual void SetWebSocketHandshakeStreamCreateHelper( 75 WebSocketHandshakeStreamBase::CreateHelper* create_helper) OVERRIDE; 76 virtual void SetBeforeNetworkStartCallback( 77 const BeforeNetworkStartCallback& callback) OVERRIDE; 78 virtual int ResumeNetworkStart() OVERRIDE; 79 80 // HttpStreamRequest::Delegate methods: 81 virtual void OnStreamReady(const SSLConfig& used_ssl_config, 82 const ProxyInfo& used_proxy_info, 83 HttpStreamBase* stream) OVERRIDE; 84 virtual void OnWebSocketHandshakeStreamReady( 85 const SSLConfig& used_ssl_config, 86 const ProxyInfo& used_proxy_info, 87 WebSocketHandshakeStreamBase* stream) OVERRIDE; 88 virtual void OnStreamFailed(int status, 89 const SSLConfig& used_ssl_config) OVERRIDE; 90 virtual void OnCertificateError(int status, 91 const SSLConfig& used_ssl_config, 92 const SSLInfo& ssl_info) OVERRIDE; 93 virtual void OnNeedsProxyAuth( 94 const HttpResponseInfo& response_info, 95 const SSLConfig& used_ssl_config, 96 const ProxyInfo& used_proxy_info, 97 HttpAuthController* auth_controller) OVERRIDE; 98 virtual void OnNeedsClientAuth(const SSLConfig& used_ssl_config, 99 SSLCertRequestInfo* cert_info) OVERRIDE; 100 virtual void OnHttpsProxyTunnelResponse(const HttpResponseInfo& response_info, 101 const SSLConfig& used_ssl_config, 102 const ProxyInfo& used_proxy_info, 103 HttpStreamBase* stream) OVERRIDE; 104 105 private: 106 friend class HttpNetworkTransactionSSLTest; 107 108 FRIEND_TEST_ALL_PREFIXES(HttpNetworkTransactionTest, 109 ResetStateForRestart); 110 FRIEND_TEST_ALL_PREFIXES(SpdyNetworkTransactionTest, 111 WindowUpdateReceived); 112 FRIEND_TEST_ALL_PREFIXES(SpdyNetworkTransactionTest, 113 WindowUpdateSent); 114 FRIEND_TEST_ALL_PREFIXES(SpdyNetworkTransactionTest, 115 WindowUpdateOverflow); 116 FRIEND_TEST_ALL_PREFIXES(SpdyNetworkTransactionTest, 117 FlowControlStallResume); 118 FRIEND_TEST_ALL_PREFIXES(SpdyNetworkTransactionTest, 119 FlowControlStallResumeAfterSettings); 120 FRIEND_TEST_ALL_PREFIXES(SpdyNetworkTransactionTest, 121 FlowControlNegativeSendWindowSize); 122 123 enum State { 124 STATE_NOTIFY_BEFORE_CREATE_STREAM, 125 STATE_CREATE_STREAM, 126 STATE_CREATE_STREAM_COMPLETE, 127 STATE_INIT_STREAM, 128 STATE_INIT_STREAM_COMPLETE, 129 STATE_GENERATE_PROXY_AUTH_TOKEN, 130 STATE_GENERATE_PROXY_AUTH_TOKEN_COMPLETE, 131 STATE_GENERATE_SERVER_AUTH_TOKEN, 132 STATE_GENERATE_SERVER_AUTH_TOKEN_COMPLETE, 133 STATE_INIT_REQUEST_BODY, 134 STATE_INIT_REQUEST_BODY_COMPLETE, 135 STATE_BUILD_REQUEST, 136 STATE_BUILD_REQUEST_COMPLETE, 137 STATE_SEND_REQUEST, 138 STATE_SEND_REQUEST_COMPLETE, 139 STATE_READ_HEADERS, 140 STATE_READ_HEADERS_COMPLETE, 141 STATE_READ_BODY, 142 STATE_READ_BODY_COMPLETE, 143 STATE_DRAIN_BODY_FOR_AUTH_RESTART, 144 STATE_DRAIN_BODY_FOR_AUTH_RESTART_COMPLETE, 145 STATE_NONE 146 }; 147 148 bool is_https_request() const; 149 150 void DoCallback(int result); 151 void OnIOComplete(int result); 152 153 // Runs the state transition loop. 154 int DoLoop(int result); 155 156 // Each of these methods corresponds to a State value. Those with an input 157 // argument receive the result from the previous state. If a method returns 158 // ERR_IO_PENDING, then the result from OnIOComplete will be passed to the 159 // next state method as the result arg. 160 int DoNotifyBeforeCreateStream(); 161 int DoCreateStream(); 162 int DoCreateStreamComplete(int result); 163 int DoInitStream(); 164 int DoInitStreamComplete(int result); 165 int DoGenerateProxyAuthToken(); 166 int DoGenerateProxyAuthTokenComplete(int result); 167 int DoGenerateServerAuthToken(); 168 int DoGenerateServerAuthTokenComplete(int result); 169 int DoInitRequestBody(); 170 int DoInitRequestBodyComplete(int result); 171 int DoBuildRequest(); 172 int DoBuildRequestComplete(int result); 173 int DoSendRequest(); 174 int DoSendRequestComplete(int result); 175 int DoReadHeaders(); 176 int DoReadHeadersComplete(int result); 177 int DoReadBody(); 178 int DoReadBodyComplete(int result); 179 int DoDrainBodyForAuthRestart(); 180 int DoDrainBodyForAuthRestartComplete(int result); 181 182 void BuildRequestHeaders(bool using_proxy); 183 184 // Record histogram of time until first byte of header is received. 185 void LogTransactionConnectedMetrics(); 186 187 // Record histogram of latency (durations until last byte received). 188 void LogTransactionMetrics() const; 189 190 // Writes a log message to help debugging in the field when we block a proxy 191 // response to a CONNECT request. 192 void LogBlockedTunnelResponse(int response_code) const; 193 194 // Called to handle a client certificate request. 195 int HandleCertificateRequest(int error); 196 197 // Called to possibly handle a client authentication error. 198 void HandleClientAuthError(int error); 199 200 // Called to possibly recover from an SSL handshake error. Sets next_state_ 201 // and returns OK if recovering from the error. Otherwise, the same error 202 // code is returned. 203 int HandleSSLHandshakeError(int error); 204 205 // Called to possibly recover from the given error. Sets next_state_ and 206 // returns OK if recovering from the error. Otherwise, the same error code 207 // is returned. 208 int HandleIOError(int error); 209 210 // Gets the response headers from the HttpStream. 211 HttpResponseHeaders* GetResponseHeaders() const; 212 213 // Called when the socket is unexpectedly closed. Returns true if the request 214 // should be resent in case of a socket reuse/close race. 215 bool ShouldResendRequest() const; 216 217 // Resets the connection and the request headers for resend. Called when 218 // ShouldResendRequest() is true. 219 void ResetConnectionAndRequestForResend(); 220 221 // Sets up the state machine to restart the transaction with auth. 222 void PrepareForAuthRestart(HttpAuth::Target target); 223 224 // Called when we don't need to drain the response body or have drained it. 225 // Resets |connection_| unless |keep_alive| is true, then calls 226 // ResetStateForRestart. Sets |next_state_| appropriately. 227 void DidDrainBodyForAuthRestart(bool keep_alive); 228 229 // Resets the members of the transaction so it can be restarted. 230 void ResetStateForRestart(); 231 232 // Resets the members of the transaction, except |stream_|, which needs 233 // to be maintained for multi-round auth. 234 void ResetStateForAuthRestart(); 235 236 // Returns true if we should try to add a Proxy-Authorization header 237 bool ShouldApplyProxyAuth() const; 238 239 // Returns true if we should try to add an Authorization header. 240 bool ShouldApplyServerAuth() const; 241 242 // Handles HTTP status code 401 or 407. 243 // HandleAuthChallenge() returns a network error code, or OK on success. 244 // May update |pending_auth_target_| or |response_.auth_challenge|. 245 int HandleAuthChallenge(); 246 247 // Returns true if we have auth credentials for the given target. 248 bool HaveAuth(HttpAuth::Target target) const; 249 250 // Get the {scheme, host, path, port} for the authentication target 251 GURL AuthURL(HttpAuth::Target target) const; 252 253 // Returns true if this transaction is for a WebSocket handshake 254 bool ForWebSocketHandshake() const; 255 256 // Debug helper. 257 static std::string DescribeState(State state); 258 259 void SetStream(HttpStreamBase* stream); 260 261 scoped_refptr<HttpAuthController> 262 auth_controllers_[HttpAuth::AUTH_NUM_TARGETS]; 263 264 // Whether this transaction is waiting for proxy auth, server auth, or is 265 // not waiting for any auth at all. |pending_auth_target_| is read and 266 // cleared by RestartWithAuth(). 267 HttpAuth::Target pending_auth_target_; 268 269 CompletionCallback io_callback_; 270 CompletionCallback callback_; 271 272 HttpNetworkSession* session_; 273 274 BoundNetLog net_log_; 275 const HttpRequestInfo* request_; 276 RequestPriority priority_; 277 HttpResponseInfo response_; 278 279 // |proxy_info_| is the ProxyInfo used by the HttpStreamRequest. 280 ProxyInfo proxy_info_; 281 282 scoped_ptr<HttpStreamRequest> stream_request_; 283 scoped_ptr<HttpStreamBase> stream_; 284 285 // True if we've validated the headers that the stream parser has returned. 286 bool headers_valid_; 287 288 // True if we've logged the time of the first response byte. Used to 289 // prevent logging across authentication activity where we see multiple 290 // responses. 291 bool logged_response_time_; 292 293 SSLConfig server_ssl_config_; 294 SSLConfig proxy_ssl_config_; 295 // fallback_error_code contains the error code that caused the last TLS 296 // fallback. If the fallback connection results in 297 // ERR_SSL_INAPPROPRIATE_FALLBACK (i.e. the server indicated that the 298 // fallback should not have been needed) then we use this value to return the 299 // original error that triggered the fallback. 300 int fallback_error_code_; 301 302 HttpRequestHeaders request_headers_; 303 304 // The size in bytes of the buffer we use to drain the response body that 305 // we want to throw away. The response body is typically a small error 306 // page just a few hundred bytes long. 307 static const int kDrainBodyBufferSize = 1024; 308 309 // User buffer and length passed to the Read method. 310 scoped_refptr<IOBuffer> read_buf_; 311 int read_buf_len_; 312 313 // Total number of bytes received on streams for this transaction. 314 int64 total_received_bytes_; 315 316 // The time the Start method was called. 317 base::Time start_time_; 318 319 // When the transaction started / finished sending the request, including 320 // the body, if present. 321 base::TimeTicks send_start_time_; 322 base::TimeTicks send_end_time_; 323 324 // The next state in the state machine. 325 State next_state_; 326 327 // True when the tunnel is in the process of being established - we can't 328 // read from the socket until the tunnel is done. 329 bool establishing_tunnel_; 330 331 // The helper object to use to create WebSocketHandshakeStreamBase 332 // objects. Only relevant when establishing a WebSocket connection. 333 WebSocketHandshakeStreamBase::CreateHelper* 334 websocket_handshake_stream_base_create_helper_; 335 336 BeforeNetworkStartCallback before_network_start_callback_; 337 338 DISALLOW_COPY_AND_ASSIGN(HttpNetworkTransaction); 339 }; 340 341 } // namespace net 342 343 #endif // NET_HTTP_HTTP_NETWORK_TRANSACTION_H_ 344